diff --git a/httpclient5-testing/src/test/java/org/apache/hc/client5/testing/AddressSelectingDnsResolverIT.java b/httpclient5-testing/src/test/java/org/apache/hc/client5/testing/AddressSelectingDnsResolverIT.java
new file mode 100644
index 0000000000..9f365669fa
--- /dev/null
+++ b/httpclient5-testing/src/test/java/org/apache/hc/client5/testing/AddressSelectingDnsResolverIT.java
@@ -0,0 +1,254 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+
+package org.apache.hc.client5.testing;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.hc.client5.http.AddressSelectingDnsResolver;
+import org.apache.hc.client5.http.DnsResolver;
+import org.apache.hc.client5.http.SystemDefaultDnsResolver;
+import org.apache.hc.client5.http.config.ProtocolFamilyPreference;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
+
+@EnabledIfSystemProperty(named = "httpclient.rfc6724.it", matches = "true")
+class AddressSelectingDnsResolverIT {
+
+    private static final String PROP_HOST = "httpclient.rfc6724.host";
+
+    @Test
+    void interleave_isStableInterleavingOfDefault_forSameResolution() throws Exception {
+        final String host = System.getProperty(PROP_HOST, "localhost");
+
+        final InetAddress[] resolvedOnce = SystemDefaultDnsResolver.INSTANCE.resolve(host);
+
+        final DnsResolver captured = new DnsResolver() {
+            @Override
+            public InetAddress[] resolve(final String h) throws UnknownHostException {
+                if (!host.equals(h)) {
+                    throw new UnknownHostException(h);
+                }
+                return resolvedOnce.clone();
+            }
+
+            @Override
+            public String resolveCanonicalHostname(final String h) throws UnknownHostException {
+                return SystemDefaultDnsResolver.INSTANCE.resolveCanonicalHostname(h);
+            }
+        };
+
+        final AddressSelectingDnsResolver rDefault =
+                new AddressSelectingDnsResolver(captured, ProtocolFamilyPreference.DEFAULT);
+
+        final AddressSelectingDnsResolver rInterleave =
+                new AddressSelectingDnsResolver(captured, ProtocolFamilyPreference.INTERLEAVE);
+
+        final InetAddress[] outDefault = rDefault.resolve(host);
+        final InetAddress[] outInterleave = rInterleave.resolve(host);
+
+        // 0) Both outputs must be permutations of the captured, single resolution.
+        Assertions.assertNotNull(outDefault);
+        assertSameElements(Arrays.asList(resolvedOnce), Arrays.asList(outDefault));
+        Assertions.assertNotNull(outInterleave);
+        assertSameElements(Arrays.asList(resolvedOnce), Arrays.asList(outInterleave));
+
+        // 1) Same elements between DEFAULT and INTERLEAVE (no drops, no additions).
+        assertSameElements(Arrays.asList(outDefault), Arrays.asList(outInterleave));
+
+        // 2) Family counts must match between DEFAULT and INTERLEAVE.
+        final Counts cDefault = countFamilies(outDefault);
+        final Counts cInterleave = countFamilies(outInterleave);
+        assertEquals(cDefault.v4, cInterleave.v4);
+        assertEquals(cDefault.v6, cInterleave.v6);
+
+        // 3) INTERLEAVE must be the stable interleaving of the DEFAULT-ordered list.
+        final List<InetAddress> expected = expectedInterleaveFromBaseline(Arrays.asList(outDefault));
+        assertEquals(expected, Arrays.asList(outInterleave));
+
+        // 4) If both families are present, the first 2*min(v4,v6) addresses must alternate by family.
+        final int pairs = Math.min(cInterleave.v4, cInterleave.v6);
+        if (pairs > 0) {
+            assertAlternatingPrefix(outInterleave, 2 * pairs);
+        }
+
+        // 5) Relative order within each family is preserved from DEFAULT.
+        assertFamilyRelativeOrderPreserved(outDefault, outInterleave);
+
+        // Diagnostics for manual runs.
+        System.out.println("Host: " + host);
+        dump("DEFAULT", outDefault);
+        dump("INTERLEAVE", outInterleave);
+    }
+
+    private static void assertSameElements(final List<InetAddress> a, final List<InetAddress> b) {
+        assertEquals(a.size(), b.size());
+
+        final List<InetAddress> remaining = new ArrayList<>(b);
+        for (final InetAddress x : a) {
+            assertTrue(remaining.remove(x), "Missing address: " + x);
+        }
+        assertTrue(remaining.isEmpty(), "Extra addresses: " + remaining);
+    }
+
+    private static final class Counts {
+        final int v4;
+        final int v6;
+
+        Counts(final int v4, final int v6) {
+            this.v4 = v4;
+            this.v6 = v6;
+        }
+    }
+
+    private static Counts countFamilies(final InetAddress[] out) {
+        int v4 = 0;
+        int v6 = 0;
+        for (final InetAddress a : out) {
+            if (a instanceof Inet6Address) {
+                v6++;
+            } else {
+                v4++;
+            }
+        }
+        return new Counts(v4, v6);
+    }
+
+    private static void assertAlternatingPrefix(final InetAddress[] out, final int length) {
+        if (length <= 1) {
+            return;
+        }
+        final boolean firstV6 = out[0] instanceof Inet6Address;
+        for (int i = 0; i < length; i++) {
+            final boolean expectV6 = firstV6 == (i % 2 == 0);
+            final boolean isV6 = out[i] instanceof Inet6Address;
+            assertEquals(expectV6, isV6, "Not alternating at index " + i);
+        }
+    }
+
+    private static void assertFamilyRelativeOrderPreserved(
+            final InetAddress[] base,
+            final InetAddress[] interleaved) {
+
+        final List<InetAddress> baseV6 = new ArrayList<>();
+        final List<InetAddress> baseV4 = new ArrayList<>();
+        for (final InetAddress a : base) {
+            if (a instanceof Inet6Address) {
+                baseV6.add(a);
+            } else {
+                baseV4.add(a);
+            }
+        }
+
+        final List<InetAddress> gotV6 = new ArrayList<>();
+        final List<InetAddress> gotV4 = new ArrayList<>();
+        for (final InetAddress a : interleaved) {
+            if (a instanceof Inet6Address) {
+                gotV6.add(a);
+            } else {
+                gotV4.add(a);
+            }
+        }
+
+        assertEquals(baseV6, gotV6, "IPv6 relative order changed");
+        assertEquals(baseV4, gotV4, "IPv4 relative order changed");
+    }
+
+    private static List<InetAddress> expectedInterleaveFromBaseline(final List<InetAddress> baseline) {
+        if (baseline.size() <= 1) {
+            return baseline;
+        }
+
+        final List<InetAddress> v6 = new ArrayList<>();
+        final List<InetAddress> v4 = new ArrayList<>();
+
+        for (final InetAddress a : baseline) {
+            if (a instanceof Inet6Address) {
+                v6.add(a);
+            } else {
+                v4.add(a);
+            }
+        }
+
+        if (v6.isEmpty() || v4.isEmpty()) {
+            return baseline;
+        }
+
+        final boolean startV6 = baseline.get(0) instanceof Inet6Address;
+
+        final List<InetAddress> out = new ArrayList<>(baseline.size());
+        int i6 = 0;
+        int i4 = 0;
+
+        while (i6 < v6.size() || i4 < v4.size()) {
+            if (startV6) {
+                if (i6 < v6.size()) {
+                    out.add(v6.get(i6++));
+                }
+                if (i4 < v4.size()) {
+                    out.add(v4.get(i4++));
+                }
+            } else {
+                if (i4 < v4.size()) {
+                    out.add(v4.get(i4++));
+                }
+                if (i6 < v6.size()) {
+                    out.add(v6.get(i6++));
+                }
+            }
+        }
+
+        return out;
+    }
+
+    private static void dump(final String label, final InetAddress[] out) {
+        int v4 = 0;
+        int v6 = 0;
+
+        System.out.println("Preference: " + label);
+        for (final InetAddress a : out) {
+            if (a instanceof Inet6Address) {
+                v6++;
+                System.out.println("  IPv6 " + a.getHostAddress());
+            } else {
+                v4++;
+                System.out.println("  IPv4 " + a.getHostAddress());
+            }
+        }
+        System.out.println("Counts: IPv4=" + v4 + " IPv6=" + v6);
+        System.out.println();
+    }
+}
diff --git a/httpclient5/src/main/java/org/apache/hc/client5/http/AddressSelectingDnsResolver.java b/httpclient5/src/main/java/org/apache/hc/client5/http/AddressSelectingDnsResolver.java
new file mode 100644
index 0000000000..052ba90045
--- /dev/null
+++ b/httpclient5/src/main/java/org/apache/hc/client5/http/AddressSelectingDnsResolver.java
@@ -0,0 +1,698 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+
+package org.apache.hc.client5.http;
+
+import java.net.DatagramSocket;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import org.apache.hc.client5.http.config.ProtocolFamilyPreference;
+import org.apache.hc.core5.annotation.Contract;
+import org.apache.hc.core5.annotation.ThreadingBehavior;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * {@code AddressSelectingDnsResolver} wraps a delegate {@link DnsResolver}
+ * and applies RFC&nbsp;6724 destination address selection rules (RFC 6724 §6)
+ * to the returned addresses. It can also enforce or bias a protocol family preference.
+ *
+ * <p>The canonical hostname lookup is delegated unchanged.</p>
+ *
+ * <p>
+ * {@link ProtocolFamilyPreference#DEFAULT} keeps the RFC 6724 sorted order intact (no family bias).
+ * {@link ProtocolFamilyPreference#INTERLEAVE} interleaves IPv6 and IPv4 addresses (v6, v4, v6, …),
+ * preserving the relative order within each family as produced by RFC 6724 sorting.
+ * </p>
+ *
+ * @since 5.7
+ */
+@Contract(threading = ThreadingBehavior.IMMUTABLE)
+public final class AddressSelectingDnsResolver implements DnsResolver {
+
+    private static final Logger LOG = LoggerFactory.getLogger(AddressSelectingDnsResolver.class);
+
+    private static final int PROBE_PORT = 53; // UDP connect trick; no packets sent
+
+    @FunctionalInterface
+    interface SourceAddressResolver {
+        InetAddress resolveSource(final InetSocketAddress destination) throws SocketException;
+    }
+
+    private static final SourceAddressResolver DEFAULT_SOURCE_ADDRESS_RESOLVER = destination -> {
+        try (final DatagramSocket socket = new DatagramSocket()) {
+            socket.connect(destination);
+            return socket.getLocalAddress();
+        }
+    };
+
+    private final DnsResolver delegate;
+    private final ProtocolFamilyPreference familyPreference;
+    private final SourceAddressResolver sourceAddressResolver;
+
+    /**
+     * Creates a new resolver that applies RFC 6724 ordering with no family bias (DEFAULT).
+     *
+     * @param delegate underlying resolver to use.
+     */
+    public AddressSelectingDnsResolver(final DnsResolver delegate) {
+        this(delegate, ProtocolFamilyPreference.DEFAULT);
+    }
+
+    /**
+     * Creates a new resolver that applies RFC 6724 ordering and a specific protocol family preference.
+     *
+     * @param delegate         underlying resolver to use.
+     * @param familyPreference family preference to apply (e.g. PREFER_IPV6, IPV4_ONLY).
+     */
+    public AddressSelectingDnsResolver(
+            final DnsResolver delegate,
+            final ProtocolFamilyPreference familyPreference) {
+        this(delegate, familyPreference, DEFAULT_SOURCE_ADDRESS_RESOLVER);
+    }
+
+    // Package-private for unit tests: allows deterministic source address inference.
+    AddressSelectingDnsResolver(
+            final DnsResolver delegate,
+            final ProtocolFamilyPreference familyPreference,
+            final SourceAddressResolver sourceAddressResolver) {
+        this.delegate = Objects.requireNonNull(delegate, "delegate");
+        this.familyPreference = familyPreference != null ? familyPreference : ProtocolFamilyPreference.DEFAULT;
+        this.sourceAddressResolver = sourceAddressResolver != null ? sourceAddressResolver : DEFAULT_SOURCE_ADDRESS_RESOLVER;
+    }
+
+    @Override
+    public InetAddress[] resolve(final String host) throws UnknownHostException {
+        final InetAddress[] resolved = delegate.resolve(host);
+
+        if (resolved == null) {
+            if (LOG.isDebugEnabled()) {
+                LOG.debug("resolved '{}' -> null", host);
+            }
+            return null;
+        }
+
+        if (LOG.isTraceEnabled()) {
+            LOG.trace("resolving host '{}' via delegate {}", host, delegate.getClass().getName());
+            LOG.trace("familyPreference={}", familyPreference);
+            LOG.trace("delegate returned {} addresses for '{}': {}", resolved.length, host, fmt(resolved));
+        }
+
+        // Always filter, even for a single address — the family preference may exclude it.
+        final List<InetAddress> candidates = filterCandidates(resolved, familyPreference);
+
+        if (candidates.isEmpty()) {
+            if (LOG.isDebugEnabled()) {
+                LOG.debug("resolved '{}' -> []", host);
+            }
+            return null;
+        }
+
+        if (candidates.size() == 1) {
+            if (LOG.isDebugEnabled()) {
+                LOG.debug("resolved '{}' -> {}", host, fmt(candidates));
+            }
+            return candidates.toArray(new InetAddress[0]);
+        }
+
+        final List<InetAddress> rfcSorted = sortByRfc6724(candidates);
+        final List<InetAddress> ordered = applyFamilyPreference(rfcSorted, familyPreference);
+
+        if (LOG.isDebugEnabled()) {
+            LOG.debug("resolved '{}' -> {}", host, fmt(ordered));
+        }
+
+        return ordered.toArray(new InetAddress[0]);
+    }
+
+    @Override
+    public List<InetSocketAddress> resolve(final String host, final int port) throws UnknownHostException {
+        final InetAddress[] ordered = resolve(host);
+        if (ordered == null) {
+            // Do NOT fall back to createUnresolved: an unresolved address would let
+            // downstream code re-resolve the hostname and bypass family filtering
+            // (e.g. IPV4_ONLY / IPV6_ONLY).
+            throw new UnknownHostException(host);
+        }
+        return Arrays.stream(ordered)
+                .map(a -> new InetSocketAddress(a, port))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public String resolveCanonicalHostname(final String host) throws UnknownHostException {
+        if (LOG.isTraceEnabled()) {
+            LOG.trace("resolveCanonicalHostname('{}') via delegate {}", host, delegate.getClass().getName());
+        }
+        return delegate.resolveCanonicalHostname(host);
+    }
+
+    private static boolean isUsableDestination(final InetAddress ip) {
+        if (ip == null) {
+            return false;
+        }
+        if (ip.isAnyLocalAddress()) {
+            return false;
+        }
+        // HTTP/TCP is for unicast destinations; multicast is not a valid connect target.
+        return !ip.isMulticastAddress();
+    }
+
+
+    private static List<InetAddress> filterCandidates(
+            final InetAddress[] resolved,
+            final ProtocolFamilyPreference pref) {
+
+        return Arrays.stream(resolved)
+                .filter(AddressSelectingDnsResolver::isUsableDestination)
+                .filter(a -> shouldInclude(pref, a))
+                .collect(Collectors.toList());
+    }
+
+    private static boolean shouldInclude(final ProtocolFamilyPreference pref, final InetAddress a) {
+        switch (pref) {
+            case IPV4_ONLY:
+                return a instanceof Inet4Address;
+            case IPV6_ONLY:
+                return a instanceof Inet6Address;
+            default:
+                return true;
+        }
+    }
+
+
+    // --- RFC 6724 helpers ---
+
+    private List<InetAddress> sortByRfc6724(final List<InetAddress> addrs) {
+        if (addrs.size() < 2) {
+            return addrs;
+        }
+
+        if (LOG.isTraceEnabled()) {
+            LOG.trace("RFC6724 input candidates: {}", fmt(addrs));
+        }
+
+        final List<Info> infos = new ArrayList<>(addrs.size());
+        for (final InetAddress dst : addrs) {
+            final InetAddress src = inferSourceAddress(new InetSocketAddress(dst, PROBE_PORT));
+            infos.add(new Info(dst, src, ipAttrOf(dst), ipAttrOf(src)));
+        }
+
+        if (LOG.isTraceEnabled()) {
+            for (final Info info : infos) {
+                LOG.trace("RFC6724 candidate dst={} src={} dst[scope={},prec={},label={}] src[scope={},prec={},label={}]",
+                        addr(info.dst), addr(info.src),
+                        info.dstAttr.scope, info.dstAttr.precedence, info.dstAttr.label,
+                        info.srcAttr.scope, info.srcAttr.precedence, info.srcAttr.label);
+            }
+        }
+
+        infos.sort(RFC6724_COMPARATOR);
+
+        final List<InetAddress> out = infos.stream()
+                .map(info -> info.dst)
+                .collect(Collectors.toList());
+
+        if (LOG.isTraceEnabled()) {
+            LOG.trace("RFC6724 output order: {}", fmt(out));
+        }
+
+        return out;
+    }
+
+    private InetAddress inferSourceAddress(final InetSocketAddress destination) {
+        try {
+            return sourceAddressResolver.resolveSource(destination);
+        } catch (final SocketException ex) {
+            if (LOG.isTraceEnabled()) {
+                LOG.trace("RFC6724 could not infer source address for {}: {}", destination, ex.toString());
+            }
+            return null;
+        }
+    }
+
+    private static List<InetAddress> applyFamilyPreference(
+            final List<InetAddress> rfcSorted,
+            final ProtocolFamilyPreference pref) {
+
+        if (rfcSorted.size() <= 1) {
+            return rfcSorted;
+        }
+
+        switch (pref) {
+            case PREFER_IPV6:
+            case PREFER_IPV4: {
+                final boolean preferV6 = pref == ProtocolFamilyPreference.PREFER_IPV6;
+
+                // Stable: preserves the RFC6724 order within each family.
+                final List<InetAddress> out = rfcSorted.stream()
+                        .sorted(Comparator.comparingInt(a -> ((a instanceof Inet6Address) == preferV6) ? 0 : 1))
+                        .collect(Collectors.toList());
+
+                if (LOG.isTraceEnabled()) {
+                    LOG.trace("Family preference {} applied. Output: {}", pref, fmt(out));
+                }
+                return out;
+            }
+            case INTERLEAVE: {
+                final List<InetAddress> out = interleaveFamilies(rfcSorted);
+                if (LOG.isTraceEnabled()) {
+                    LOG.trace("Family preference {} applied. Output: {}", pref, fmt(out));
+                }
+                return out;
+            }
+            case IPV4_ONLY:
+            case IPV6_ONLY: {
+                // already filtered earlier
+                return rfcSorted;
+            }
+            case DEFAULT:
+            default: {
+                // No family bias. Keep RFC 6724 order intact.
+                return rfcSorted;
+            }
+        }
+    }
+
+    private static List<InetAddress> interleaveFamilies(final List<InetAddress> rfcSorted) {
+        final List<InetAddress> v6 = new ArrayList<>();
+        final List<InetAddress> v4 = new ArrayList<>();
+
+        for (final InetAddress a : rfcSorted) {
+            if (a instanceof Inet6Address) {
+                v6.add(a);
+            } else {
+                v4.add(a);
+            }
+        }
+
+        if (v6.isEmpty() || v4.isEmpty()) {
+            return rfcSorted;
+        }
+
+        final boolean startWithV6 = rfcSorted.get(0) instanceof Inet6Address;
+        final List<InetAddress> first = startWithV6 ? v6 : v4;
+        final List<InetAddress> second = startWithV6 ? v4 : v6;
+
+        final List<InetAddress> out = new ArrayList<>(rfcSorted.size());
+        final Iterator<InetAddress> it1 = first.iterator();
+        final Iterator<InetAddress> it2 = second.iterator();
+        while (it1.hasNext() || it2.hasNext()) {
+            if (it1.hasNext()) {
+                out.add(it1.next());
+            }
+            if (it2.hasNext()) {
+                out.add(it2.next());
+            }
+        }
+        return out;
+    }
+
+    // --- RFC 6724 score structs ---
+
+    private static final class Info {
+        final InetAddress dst;
+        final InetAddress src;
+        final Attr dstAttr;
+        final Attr srcAttr;
+
+        Info(final InetAddress dst, final InetAddress src, final Attr dstAttr, final Attr srcAttr) {
+            this.dst = dst;
+            this.src = src;
+            this.dstAttr = dstAttr;
+            this.srcAttr = srcAttr;
+        }
+    }
+
+    private static final class Attr {
+        final Scope scope;
+        final int precedence;
+        final int label;
+
+        Attr(final Scope scope, final int precedence, final int label) {
+            this.scope = scope;
+            this.precedence = precedence;
+            this.label = label;
+        }
+    }
+
+    // Package-private for unit testing.
+    enum Scope {
+        INTERFACE_LOCAL(0x1),
+        LINK_LOCAL(0x2),
+        ADMIN_LOCAL(0x4),
+        SITE_LOCAL(0x5),
+        ORG_LOCAL(0x8),
+        GLOBAL(0xe);
+
+        final int value;
+
+        Scope(final int v) {
+            this.value = v;
+        }
+
+        static Scope fromValue(final int v) {
+            switch (v) {
+                case 0x1: {
+                    return INTERFACE_LOCAL;
+                }
+                case 0x2: {
+                    return LINK_LOCAL;
+                }
+                case 0x4: {
+                    return ADMIN_LOCAL;
+                }
+                case 0x5: {
+                    return SITE_LOCAL;
+                }
+                case 0x8: {
+                    return ORG_LOCAL;
+                }
+                case 0xe: {
+                    return GLOBAL;
+                }
+                default: {
+                    throw new IllegalArgumentException("Unknown scope value: 0x" + Integer.toHexString(v));
+                }
+            }
+        }
+    }
+
+    private static Attr ipAttrOf(final InetAddress ip) {
+        if (ip == null) {
+            return new Attr(Scope.GLOBAL, 0, 0);
+        }
+        final PolicyEntry e = classify(ip);
+        return new Attr(classifyScope(ip), e.precedence, e.label);
+    }
+
+    // Package-private for unit testing.
+    //
+    // RFC 6724 §3.1 scope assignment:
+    //   IPv6 ::1              → link-local  (interface-local is multicast-only per RFC 4291 §2.7)
+    //   IPv6 link-local       → link-local
+    //   IPv6 site-local       → site-local  (deprecated but still defined)
+    //   IPv6 multicast        → scope nibble from second byte (RFC 4291)
+    //   IPv6 ULA (fc00::/7)   → global  (handled via policy table, not scope)
+    //   IPv6 everything else  → global
+    //
+    //   IPv4 127/8            → link-local
+    //   IPv4 169.254/16       → link-local
+    //   IPv4 everything else  → global  (including RFC1918 and 100.64/10)
+    //
+    static Scope classifyScope(final InetAddress ip) {
+        if (ip instanceof Inet4Address) {
+            // IPv4 scope rules per RFC 6724 §3.1:
+            // Only loopback (127/8) and link-local (169.254/16) get link-local scope;
+            // all other IPv4 addresses (including RFC1918 private and 100.64/10) are global.
+            if (ip.isLoopbackAddress() || ip.isLinkLocalAddress()) {
+                return Scope.LINK_LOCAL;
+            }
+            return Scope.GLOBAL;
+        }
+
+        // IPv6 scope rules.
+        if (ip.isLoopbackAddress()) {
+            // Interface-local scope (0x1) is a multicast-only concept (RFC 4291 §2.7).
+            // For unicast, the smallest meaningful scope is link-local.
+            return Scope.LINK_LOCAL;
+        }
+        if (ip.isLinkLocalAddress()) {
+            return Scope.LINK_LOCAL;
+        }
+        if (ip.isMulticastAddress()) {
+            // RFC 6724 §3.1 and RFC 4291: low 4 bits of second byte encode scope for IPv6 multicast.
+            // Not all nibble values map to a known Scope constant; treat unknown values as GLOBAL.
+            final int nibble = ip.getAddress()[1] & 0x0f;
+            try {
+                return Scope.fromValue(nibble);
+            } catch (final IllegalArgumentException e) {
+                return Scope.GLOBAL;
+            }
+        }
+        if (ip.isSiteLocalAddress()) {
+            return Scope.SITE_LOCAL;
+        }
+        return Scope.GLOBAL;
+    }
+
+    private static final class PolicyEntry {
+        final Network prefix;
+        final int precedence;
+        final int label;
+
+        PolicyEntry(final Network prefix, final int precedence, final int label) {
+            this.prefix = prefix;
+            this.precedence = precedence;
+            this.label = label;
+        }
+    }
+
+    // Package-private for unit testing.
+    static final class Network {
+        final byte[] ip;
+        final int bits;
+
+        Network(final byte[] ip, final int bits) {
+            this.ip = ip;
+            this.bits = bits;
+        }
+
+        boolean contains(final InetAddress addr) {
+            final byte[] a = addr instanceof Inet4Address ? v4toMapped(addr.getAddress()) : addr.getAddress();
+            if (a.length != ip.length) {
+                return false;
+            }
+            final int fullBytes = bits / 8;
+            for (int i = 0; i < fullBytes; i++) {
+                if (a[i] != ip[i]) {
+                    return false;
+                }
+            }
+            final int rem = bits % 8;
+            if (rem == 0) {
+                return true;
+            }
+            final int mask = 0xff << (8 - rem);
+            final int aByte = a[fullBytes] & 0xff;
+            final int ipByte = ip[fullBytes] & 0xff;
+            return (aByte & mask) == (ipByte & mask);
+        }
+
+        private static byte[] v4toMapped(final byte[] v4) {
+            final byte[] mapped = new byte[16];
+            mapped[10] = (byte) 0xff;
+            mapped[11] = (byte) 0xff;
+            System.arraycopy(v4, 0, mapped, 12, 4);
+            return mapped;
+        }
+    }
+
+    private static Network toPrefix(final String text, final int bits) {
+        try {
+            return new Network(InetAddress.getByName(text).getAddress(), bits);
+        } catch (final UnknownHostException ex) {
+            throw new IllegalArgumentException(ex);
+        }
+    }
+
+    private static final List<PolicyEntry> POLICY_TABLE =
+            Collections.unmodifiableList(Arrays.asList(
+                    new PolicyEntry(toPrefix("::1", 128), 50, 0),
+                    new PolicyEntry(toPrefix("::ffff:0:0", 96), 35, 4),
+                    new PolicyEntry(toPrefix("::", 96), 1, 3),
+                    new PolicyEntry(toPrefix("2001::", 32), 5, 5),
+                    new PolicyEntry(toPrefix("2002::", 16), 30, 2),
+                    new PolicyEntry(toPrefix("3ffe::", 16), 1, 12),
+                    new PolicyEntry(toPrefix("fec0::", 10), 1, 11),
+                    new PolicyEntry(toPrefix("fc00::", 7), 3, 13),
+                    new PolicyEntry(toPrefix("::", 0), 40, 1)
+            ));
+
+    private static PolicyEntry classify(final InetAddress ip) {
+        for (final PolicyEntry e : POLICY_TABLE) {
+            if (e.prefix.contains(ip)) {
+                return e;
+            }
+        }
+        return new PolicyEntry(null, 40, 1);
+    }
+
+    private static final Comparator<Info> RFC6724_COMPARATOR = (a, b) -> {
+        final InetAddress aDst = a.dst;
+        final InetAddress bDst = b.dst;
+        final InetAddress aSrc = a.src;
+        final InetAddress bSrc = b.src;
+        final Attr aDstAttr = a.dstAttr;
+        final Attr bDstAttr = b.dstAttr;
+        final Attr aSrcAttr = a.srcAttr;
+        final Attr bSrcAttr = b.srcAttr;
+
+        final int preferA = -1;
+        final int preferB = 1;
+
+        // RFC 6724 §6: destination address selection rules.
+        //
+        // Rules 3, 4 and 7 are not implementable with standard JDK APIs:
+        //   Rule 3 (Avoid deprecated source addresses) — InetAddress exposes no deprecation state.
+        //   Rule 4 (Prefer home addresses) — Mobile IPv6 concept; not applicable to an HTTP client.
+        //   Rule 7 (Prefer native transport) — JDK provides no encapsulation/tunneling info.
+
+        // Rule 1: Avoid unusable destinations.
+        final boolean validA = aSrc != null && !aSrc.isAnyLocalAddress();
+        final boolean validB = bSrc != null && !bSrc.isAnyLocalAddress();
+        if (!validA && !validB) {
+            return 0;
+        }
+        if (!validB) {
+            return preferA;
+        }
+        if (!validA) {
+            return preferB;
+        }
+
+        // Rule 2: Prefer matching scope.
+        if (aDstAttr.scope == aSrcAttr.scope && bDstAttr.scope != bSrcAttr.scope) {
+            return preferA;
+        }
+        if (aDstAttr.scope != aSrcAttr.scope && bDstAttr.scope == bSrcAttr.scope) {
+            return preferB;
+        }
+
+        // Rule 3: Avoid deprecated addresses — skipped (see above).
+
+        // Rule 4: Prefer home addresses — skipped (see above).
+
+        // Rule 5: Prefer matching label.
+        if (aSrcAttr.label == aDstAttr.label && bSrcAttr.label != bDstAttr.label) {
+            return preferA;
+        }
+        if (aSrcAttr.label != aDstAttr.label && bSrcAttr.label == bDstAttr.label) {
+            return preferB;
+        }
+
+        // Rule 6: Prefer higher precedence.
+        if (aDstAttr.precedence > bDstAttr.precedence) {
+            return preferA;
+        }
+        if (aDstAttr.precedence < bDstAttr.precedence) {
+            return preferB;
+        }
+
+        // Rule 7: Prefer native transport — skipped (see above).
+
+        // Rule 8: Prefer smaller scope.
+        if (aDstAttr.scope.value < bDstAttr.scope.value) {
+            return preferA;
+        }
+        if (aDstAttr.scope.value > bDstAttr.scope.value) {
+            return preferB;
+        }
+
+        // Rule 9: Use longest matching prefix (RFC 6724 §6).
+        // Applies when DA and DB belong to the same address family.
+        //
+        // Note: this is an approximation. A fully correct implementation would
+        // use the source address's on-link prefix length (from the interface
+        // configuration / routing table), not the bit-wise common-prefix of
+        // source and destination. The JDK does not expose interface prefix
+        // lengths for source address selection, so we fall back to
+        // CommonPrefixLen(Source(D), D) as a reasonable heuristic.
+        if (aDst.getClass() == bDst.getClass()) {
+            final int commonA = commonPrefixLen(aSrc, aDst);
+            final int commonB = commonPrefixLen(bSrc, bDst);
+            if (commonA > commonB) {
+                return preferA;
+            }
+            if (commonA < commonB) {
+                return preferB;
+            }
+        }
+
+        // Rule 10: Otherwise equal (original order preserved by stable sort).
+        return 0;
+    };
+
+    private static int commonPrefixLen(final InetAddress a, final InetAddress b) {
+        if (a == null || b == null || a.getClass() != b.getClass()) {
+            return 0;
+        }
+        final byte[] aa = a.getAddress();
+        final byte[] bb = b.getAddress();
+        final int len = Math.min(aa.length, bb.length);
+        int bits = 0;
+        for (int i = 0; i < len; i++) {
+            final int x = (aa[i] ^ bb[i]) & 0xFF;
+            if (x == 0) {
+                bits += 8;
+            } else {
+                for (int j = 7; j >= 0; j--) {
+                    if ((x & (1 << j)) != 0) {
+                        return bits;
+                    }
+                    bits++;
+                }
+                return bits;
+            }
+        }
+        return bits;
+    }
+
+    static String addr(final InetAddress a) {
+        if (a == null) {
+            return "null";
+        }
+        final String family = a instanceof Inet6Address ? "IPv6" : "IPv4";
+        return family + "(" + a.getHostAddress() + ")";
+    }
+
+    static List<String> fmt(final InetAddress[] arr) {
+        return Arrays.stream(arr)
+                .map(AddressSelectingDnsResolver::addr)
+                .collect(Collectors.toList());
+    }
+
+    static List<String> fmt(final List<InetAddress> arr) {
+        return arr.stream()
+                .map(AddressSelectingDnsResolver::addr)
+                .collect(Collectors.toList());
+    }
+
+}
diff --git a/httpclient5/src/main/java/org/apache/hc/client5/http/config/ProtocolFamilyPreference.java b/httpclient5/src/main/java/org/apache/hc/client5/http/config/ProtocolFamilyPreference.java
new file mode 100644
index 0000000000..7ad272e3f6
--- /dev/null
+++ b/httpclient5/src/main/java/org/apache/hc/client5/http/config/ProtocolFamilyPreference.java
@@ -0,0 +1,72 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+package org.apache.hc.client5.http.config;
+
+/**
+ * Protocol family preference for outbound connections.
+ *
+ * <p>Used by connection initiation code to filter or order destination
+ * addresses and, when enabled, to interleave families during staggered attempts.
+ *
+ * @since 5.7
+ */
+public enum ProtocolFamilyPreference {
+
+    /**
+     * No family bias. Preserve RFC 6724 order.
+     */
+    DEFAULT,
+
+    /**
+     * Prefer IPv4 addresses (stable: preserves RFC order within each family).
+     */
+    PREFER_IPV4,
+
+    /**
+     * Prefer IPv6 addresses (stable: preserves RFC order within each family).
+     */
+    PREFER_IPV6,
+
+    /**
+     * Filter out all non-IPv4 addresses.
+     */
+    IPV4_ONLY,
+
+    /**
+     * Filter out all non-IPv6 addresses.
+     */
+    IPV6_ONLY,
+
+    /**
+     * Interleave address families (v6, then v4, then v6, …) when multiple
+     * addresses are available, preserving the relative order within each family
+     * as produced by RFC 6724 sorting.
+     */
+    INTERLEAVE
+
+}
+
diff --git a/httpclient5/src/test/java/org/apache/hc/client5/http/AddressSelectingDnsResolverTest.java b/httpclient5/src/test/java/org/apache/hc/client5/http/AddressSelectingDnsResolverTest.java
new file mode 100644
index 0000000000..80510db647
--- /dev/null
+++ b/httpclient5/src/test/java/org/apache/hc/client5/http/AddressSelectingDnsResolverTest.java
@@ -0,0 +1,532 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+
+package org.apache.hc.client5.http;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.hc.client5.http.config.ProtocolFamilyPreference;
+import org.apache.hc.client5.http.impl.InMemoryDnsResolver;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class AddressSelectingDnsResolverTest {
+
+    private static final AddressSelectingDnsResolver.SourceAddressResolver NO_SOURCE_ADDR =
+            (final InetSocketAddress dest) -> null;
+
+    private InMemoryDnsResolver delegate;
+
+    @BeforeEach
+    void setUp() {
+        delegate = new InMemoryDnsResolver();
+    }
+
+    @Test
+    void ipv4Only_filtersOutIPv6() throws Exception {
+        final InetAddress v4 = inet("203.0.113.10"); // TEST-NET-3
+        final InetAddress v6 = inet("2001:db8::10"); // documentation prefix
+
+        delegate.add("dual.example", v6, v4);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.IPV4_ONLY, NO_SOURCE_ADDR);
+
+        final InetAddress[] ordered = r.resolve("dual.example");
+        assertEquals(1, ordered.length);
+        assertInstanceOf(Inet4Address.class, ordered[0]);
+        assertEquals(v4, ordered[0]);
+    }
+
+    @Test
+    void ipv6Only_filtersOutIPv4() throws Exception {
+        final InetAddress v4 = inet("192.0.2.1");     // TEST-NET-1
+        final InetAddress v6 = inet("2001:db8::1");
+
+        delegate.add("dual.example", v4, v6);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.IPV6_ONLY, NO_SOURCE_ADDR);
+
+        final InetAddress[] ordered = r.resolve("dual.example");
+        assertEquals(1, ordered.length);
+        assertInstanceOf(Inet6Address.class, ordered[0]);
+        assertEquals(v6, ordered[0]);
+    }
+
+    @Test
+    void ipv4Only_emptyWhenNoIPv4Candidates() throws Exception {
+        final InetAddress v6a = inet("2001:db8::1");
+        final InetAddress v6b = inet("2001:db8::2");
+
+        delegate.add("v6only.example", v6a, v6b);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.IPV4_ONLY, NO_SOURCE_ADDR);
+
+        final InetAddress[] ordered = r.resolve("v6only.example");
+        assertNull(ordered);
+    }
+
+    @Test
+    void default_hasNoFamilyBias() throws Exception {
+        final InetAddress v6a = inet("2001:db8::1");
+        final InetAddress v6b = inet("2001:db8::2");
+        final InetAddress v4a = inet("192.0.2.1");
+        final InetAddress v4b = inet("203.0.113.10");
+
+        delegate.add("dual.example", v6a, v6b, v4a, v4b);
+
+        final AddressSelectingDnsResolver r1 =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.DEFAULT, NO_SOURCE_ADDR);
+        final AddressSelectingDnsResolver r2 =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.DEFAULT, NO_SOURCE_ADDR);
+
+        final InetAddress[] out1 = r1.resolve("dual.example");
+        final InetAddress[] out2 = r2.resolve("dual.example");
+
+        assertArrayEquals(out1, out2);
+        assertEquals(4, out1.length);
+    }
+
+    @Test
+    void interleave_alternatesFamilies_preservingRelativeOrder_whenRfcSortIsNoop() throws Exception {
+        final InetAddress v6a = inet("2001:db8::1");
+        final InetAddress v6b = inet("2001:db8::2");
+        final InetAddress v4a = inet("192.0.2.1");
+        final InetAddress v4b = inet("203.0.113.10");
+
+        // With NO_SOURCE_ADDR, RFC sort becomes a stable no-op; deterministic interleave.
+        delegate.add("dual.example", v6a, v6b, v4a, v4b);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.INTERLEAVE, NO_SOURCE_ADDR);
+
+        final InetAddress[] out = r.resolve("dual.example");
+        assertEquals(Arrays.asList(v6a, v4a, v6b, v4b), Arrays.asList(out));
+    }
+
+    @Test
+    void preferIpv6_groupsAllV6First_preservingRelativeOrder_whenRfcSortIsNoop() throws Exception {
+        final InetAddress v4a = inet("192.0.2.1");
+        final InetAddress v6a = inet("2001:db8::1");
+        final InetAddress v4b = inet("203.0.113.10");
+        final InetAddress v6b = inet("2001:db8::2");
+
+        delegate.add("dual.example", v4a, v6a, v4b, v6b);
+
+        final AddressSelectingDnsResolver preferV6 =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.PREFER_IPV6, NO_SOURCE_ADDR);
+
+        final InetAddress[] out = preferV6.resolve("dual.example");
+        assertEquals(Arrays.asList(v6a, v6b, v4a, v4b), Arrays.asList(out));
+        assertInstanceOf(Inet6Address.class, out[0]);
+    }
+
+    @Test
+    void filtersOutMulticastDestinations() throws Exception {
+        final InetAddress multicastV6 = inet("ff02::1");
+        final InetAddress v6 = inet("2001:db8::1");
+
+        delegate.add("mcast.example", multicastV6, v6);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.DEFAULT, NO_SOURCE_ADDR);
+
+        final InetAddress[] out = r.resolve("mcast.example");
+        assertEquals(1, out.length);
+        assertEquals(v6, out[0]);
+    }
+
+    // -------------------------------------------------------------------------
+    // Direct tests for classifyScope(..) and Scope.fromValue(..)
+    // -------------------------------------------------------------------------
+
+    @Test
+    void classifyScope_ipv6Loopback_isLinkLocal() throws Exception {
+        // ::1 maps to link-local scope; interface-local (0x1) is multicast-only (RFC 4291 §2.7).
+        assertEquals(AddressSelectingDnsResolver.Scope.LINK_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("::1")));
+    }
+
+    @Test
+    void classifyScope_ipv4Loopback_isLinkLocal() throws Exception {
+        // IPv4 127/8 maps to link-local, NOT interface-local (RFC 6724 §3.1).
+        assertEquals(AddressSelectingDnsResolver.Scope.LINK_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("127.0.0.1")));
+        assertEquals(AddressSelectingDnsResolver.Scope.LINK_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("127.255.255.255")));
+    }
+
+    @Test
+    void classifyScope_linkLocal() throws Exception {
+        // IPv4 169.254/16 → link-local.
+        assertEquals(AddressSelectingDnsResolver.Scope.LINK_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("169.254.0.1")));
+        // IPv6 fe80::/10 → link-local.
+        assertEquals(AddressSelectingDnsResolver.Scope.LINK_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("fe80::1")));
+    }
+
+    @Test
+    void classifyScope_ipv4Private_isGlobal() throws Exception {
+        // RFC 6724: all IPv4 except 127/8 and 169.254/16 are global,
+        // including RFC1918 (10/8, 172.16/12, 192.168/16) and 100.64/10.
+        assertEquals(AddressSelectingDnsResolver.Scope.GLOBAL,
+                AddressSelectingDnsResolver.classifyScope(inet("10.0.0.1")));
+        assertEquals(AddressSelectingDnsResolver.Scope.GLOBAL,
+                AddressSelectingDnsResolver.classifyScope(inet("172.16.0.1")));
+        assertEquals(AddressSelectingDnsResolver.Scope.GLOBAL,
+                AddressSelectingDnsResolver.classifyScope(inet("192.168.1.1")));
+        assertEquals(AddressSelectingDnsResolver.Scope.GLOBAL,
+                AddressSelectingDnsResolver.classifyScope(inet("100.64.0.1")));
+    }
+
+    @Test
+    void classifyScope_ipv6SiteLocal() throws Exception {
+        // IPv6 deprecated site-local (fec0::/10) still classified as site-local per RFC 6724.
+        assertEquals(AddressSelectingDnsResolver.Scope.SITE_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("fec0::1")));
+    }
+
+    @Test
+    void classifyScope_global() throws Exception {
+        assertEquals(AddressSelectingDnsResolver.Scope.GLOBAL,
+                AddressSelectingDnsResolver.classifyScope(inet("8.8.8.8")));
+        assertEquals(AddressSelectingDnsResolver.Scope.GLOBAL,
+                AddressSelectingDnsResolver.classifyScope(inet("2003::1")));
+    }
+
+    @Test
+    void classifyScope_ipv6Multicast_usesLowNibbleScope() throws Exception {
+        // ff01::1 -> scope 0x1 -> INTERFACE_LOCAL
+        assertEquals(AddressSelectingDnsResolver.Scope.INTERFACE_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("ff01::1")));
+        // ff02::1 -> scope 0x2 -> LINK_LOCAL
+        assertEquals(AddressSelectingDnsResolver.Scope.LINK_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("ff02::1")));
+        // ff04::1 -> scope 0x4 -> ADMIN_LOCAL
+        assertEquals(AddressSelectingDnsResolver.Scope.ADMIN_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("ff04::1")));
+        // ff05::1 -> scope 0x5 -> SITE_LOCAL
+        assertEquals(AddressSelectingDnsResolver.Scope.SITE_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("ff05::1")));
+        // ff08::1 -> scope 0x8 -> ORG_LOCAL
+        assertEquals(AddressSelectingDnsResolver.Scope.ORG_LOCAL,
+                AddressSelectingDnsResolver.classifyScope(inet("ff08::1")));
+        // ff0e::1 -> scope 0xe -> GLOBAL
+        assertEquals(AddressSelectingDnsResolver.Scope.GLOBAL,
+                AddressSelectingDnsResolver.classifyScope(inet("ff0e::1")));
+    }
+
+    @Test
+    void scopeFromValue_mapsKnownConstants() {
+        assertEquals(AddressSelectingDnsResolver.Scope.INTERFACE_LOCAL,
+                AddressSelectingDnsResolver.Scope.fromValue(0x1));
+        assertEquals(AddressSelectingDnsResolver.Scope.LINK_LOCAL,
+                AddressSelectingDnsResolver.Scope.fromValue(0x2));
+        assertEquals(AddressSelectingDnsResolver.Scope.ADMIN_LOCAL,
+                AddressSelectingDnsResolver.Scope.fromValue(0x4));
+        assertEquals(AddressSelectingDnsResolver.Scope.SITE_LOCAL,
+                AddressSelectingDnsResolver.Scope.fromValue(0x5));
+        assertEquals(AddressSelectingDnsResolver.Scope.ORG_LOCAL,
+                AddressSelectingDnsResolver.Scope.fromValue(0x8));
+        assertEquals(AddressSelectingDnsResolver.Scope.GLOBAL,
+                AddressSelectingDnsResolver.Scope.fromValue(0xe));
+    }
+
+    @Test
+    void scopeFromValue_throwsOnUnknownValue() {
+        assertThrows(IllegalArgumentException.class,
+                () -> AddressSelectingDnsResolver.Scope.fromValue(0x0));
+        assertThrows(IllegalArgumentException.class,
+                () -> AddressSelectingDnsResolver.Scope.fromValue(0x3));
+        assertThrows(IllegalArgumentException.class,
+                () -> AddressSelectingDnsResolver.Scope.fromValue(0xf));
+    }
+
+    @Test
+    void rfcRule2_prefersMatchingScope() throws Exception {
+        final InetAddress aDst = inet("2001:db8::1");
+        final InetAddress bDst = inet("2001:db8::2");
+
+        // A matches scope (GLOBAL == GLOBAL); B mismatches (GLOBAL != LINK_LOCAL)
+        final InetAddress aSrc = inet("2001:db8::abcd");
+        final InetAddress bSrc = inet("fe80::1");
+
+        delegate.add("t.example", bDst, aDst);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.DEFAULT, sourceMap(aDst, aSrc, bDst, bSrc));
+
+        final InetAddress[] out = r.resolve("t.example");
+        assertEquals(Arrays.asList(aDst, bDst), Arrays.asList(out));
+    }
+
+    @Test
+    void rfcRule5_prefersMatchingLabel() throws Exception {
+        final InetAddress aDst = inet("2001:db8::1");        // label 5 (2001::/32)
+        final InetAddress bDst = inet("2001:db8::2");        // label 5
+
+        final InetAddress aSrc = inet("2001:db8::abcd");     // label 5 -> matches A
+        final InetAddress bSrc = inet("::ffff:192.0.2.1");   // label 4 -> does not match B
+
+        delegate.add("t.example", bDst, aDst);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.DEFAULT, sourceMap(aDst, aSrc, bDst, bSrc));
+
+        final InetAddress[] out = r.resolve("t.example");
+        assertEquals(Arrays.asList(aDst, bDst), Arrays.asList(out));
+    }
+
+    @Test
+    void rfcRule6_prefersHigherPrecedence() throws Exception {
+        final InetAddress aDst = inet("::1");            // precedence 50 (policy ::1)
+        final InetAddress bDst = inet("2001:db8::1");    // precedence 5  (policy 2001::/32)
+
+        final InetAddress aSrc = inet("::1");
+        final InetAddress bSrc = inet("2001:db8::abcd");
+
+        delegate.add("t.example", bDst, aDst);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.DEFAULT, sourceMap(aDst, aSrc, bDst, bSrc));
+
+        final InetAddress[] out = r.resolve("t.example");
+        assertEquals(Arrays.asList(aDst, bDst), Arrays.asList(out));
+    }
+
+    @Test
+    void rfcRule8_prefersSmallerScope_whenPrecedenceAndLabelTie() throws Exception {
+        // Both fall to ::/0 policy -> precedence 40, label 1, but different scopes.
+        final InetAddress aDst = inet("fe80::1");  // LINK_LOCAL scope (0x2)
+        final InetAddress bDst = inet("2003::1");  // GLOBAL scope     (0xe)
+
+        final InetAddress aSrc = inet("fe80::2");  // LINK_LOCAL, label 1
+        final InetAddress bSrc = inet("2003::2");  // GLOBAL, label 1
+
+        delegate.add("t.example", bDst, aDst);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.DEFAULT, sourceMap(aDst, aSrc, bDst, bSrc));
+
+        final InetAddress[] out = r.resolve("t.example");
+        assertEquals(Arrays.asList(aDst, bDst), Arrays.asList(out));
+    }
+
+    @Test
+    void rfcRule9_prefersLongestMatchingPrefix_ipv6Only() throws Exception {
+        // Both in same policy (::/0 -> prec 40, label 1), same scope (GLOBAL).
+        // A's source shares a longer prefix with its destination than B's.
+        final InetAddress aDst = inet("2003::1");
+        final InetAddress bDst = inet("2003::1:0:0:1");
+
+        // aSrc shares a full /64 with aDst; bSrc only shares /48.
+        final InetAddress aSrc = inet("2003::2");
+        final InetAddress bSrc = inet("2003::2:0:0:1");
+
+        delegate.add("t.example", bDst, aDst);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.DEFAULT, sourceMap(aDst, aSrc, bDst, bSrc));
+
+        final InetAddress[] out = r.resolve("t.example");
+        // A has longer common prefix (src=2003::2, dst=2003::1 share 127 bits)
+        // B has shorter common prefix (src=2003::2:0:0:1, dst=2003::1:0:0:1 share 79 bits)
+        assertEquals(Arrays.asList(aDst, bDst), Arrays.asList(out));
+    }
+
+    @Test
+    void classifyScope_unknownMulticastNibble_fallsBackToGlobal() throws Exception {
+        // ff03::1 -> scope nibble 0x3, which is not a known Scope constant.
+        assertEquals(AddressSelectingDnsResolver.Scope.GLOBAL,
+                AddressSelectingDnsResolver.classifyScope(inet("ff03::1")));
+    }
+
+    @Test
+    void addr_fmt_simpleName() throws Exception {
+        assertEquals("null", AddressSelectingDnsResolver.addr(null));
+
+        final InetAddress v4 = inet("192.0.2.1");
+        final InetAddress v6 = inet("2001:db8::1");
+
+        assertEquals("IPv4(" + v4.getHostAddress() + ")", AddressSelectingDnsResolver.addr(v4));
+        assertEquals("IPv6(" + v6.getHostAddress() + ")", AddressSelectingDnsResolver.addr(v6));
+
+        assertEquals(Arrays.asList("IPv6(" + v6.getHostAddress() + ")", "IPv4(" + v4.getHostAddress() + ")"),
+                AddressSelectingDnsResolver.fmt(new InetAddress[]{v6, v4}));
+
+        assertEquals(Arrays.asList("IPv4(" + v4.getHostAddress() + ")", "IPv6(" + v6.getHostAddress() + ")"),
+                AddressSelectingDnsResolver.fmt(Arrays.asList(v4, v6)));
+
+    }
+
+    private static InetAddress inet(final String s) {
+        try {
+            return InetAddress.getByName(s);
+        } catch (final UnknownHostException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    private static AddressSelectingDnsResolver.SourceAddressResolver sourceMap(
+            final InetAddress aDst, final InetAddress aSrc,
+            final InetAddress bDst, final InetAddress bSrc) {
+        return (final InetSocketAddress dest) -> {
+            final InetAddress d = dest.getAddress();
+            if (aDst.equals(d)) {
+                return aSrc;
+            }
+            if (bDst.equals(d)) {
+                return bSrc;
+            }
+            return null;
+        };
+    }
+
+
+    @Test
+    void ipv4Only_filtersSingleV6Address() throws Exception {
+        // Regression: a single IPv6 address must still be filtered when IPV4_ONLY is set.
+        final InetAddress v6 = inet("2001:db8::1");
+        delegate.add("v6.example", v6);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.IPV4_ONLY, NO_SOURCE_ADDR);
+
+        assertNull(r.resolve("v6.example"));
+    }
+
+    @Test
+    void resolveHostPort_appliesRfc6724Ordering() throws Exception {
+        final InetAddress v4 = inet("192.0.2.1");
+        final InetAddress v6 = inet("2001:db8::1");
+
+        delegate.add("dual.example", v4, v6);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.IPV4_ONLY, NO_SOURCE_ADDR);
+
+        final List<InetSocketAddress> out = r.resolve("dual.example", 443);
+        assertEquals(1, out.size());
+        assertEquals(new InetSocketAddress(v4, 443), out.get(0));
+    }
+
+    @Test
+    void resolveHostPort_throwsWhenAllFilteredOut() throws Exception {
+        // Only IPv6 addresses, but IPV4_ONLY is requested.
+        // Must throw rather than returning an unresolved address that bypasses filtering.
+        delegate.add("v6.example", inet("2001:db8::1"));
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.IPV4_ONLY, NO_SOURCE_ADDR);
+
+        assertThrows(UnknownHostException.class, () -> r.resolve("v6.example", 443));
+    }
+
+    @Test
+    void rfcRule9_appliesToIpv4Pairs() throws Exception {
+        // Both IPv4, same policy (::ffff:0:0/96 → prec 35, label 4), same scope (GLOBAL).
+        // Rule 9 should prefer the address whose source shares a longer prefix.
+        final InetAddress aDst = inet("192.0.2.1");
+        final InetAddress bDst = inet("203.0.113.1");
+
+        // aSrc shares 24 bits with aDst (192.0.2.x); bSrc shares only 8 bits with bDst (203 vs 203).
+        final InetAddress aSrc = inet("192.0.2.100");
+        final InetAddress bSrc = inet("203.0.114.1");
+
+        delegate.add("t.example", bDst, aDst);
+
+        final AddressSelectingDnsResolver r =
+                new AddressSelectingDnsResolver(delegate, ProtocolFamilyPreference.DEFAULT, sourceMap(aDst, aSrc, bDst, bSrc));
+
+        final InetAddress[] out = r.resolve("t.example");
+        // aSrc-aDst share more prefix bits than bSrc-bDst, so aDst should come first.
+        assertEquals(Arrays.asList(aDst, bDst), Arrays.asList(out));
+    }
+
+    @Test
+    void networkContains_ipv6Prefix32() throws Exception {
+        final AddressSelectingDnsResolver.Network p32 =
+                new AddressSelectingDnsResolver.Network(inet("2001:db8::").getAddress(), 32);
+
+        assertTrue(p32.contains(inet("2001:db8::1")));
+        assertTrue(p32.contains(inet("2001:db8:ffff::1")));
+
+        assertFalse(p32.contains(inet("2001:db9::1")));
+        assertFalse(p32.contains(inet("2000:db8::1")));
+    }
+
+    @Test
+    void networkContains_ipv4IsMatchedViaV4MappedWhenPrefixIsV6Mapped96() throws Exception {
+        // Build ::ffff:0:0 as raw 16 bytes. Do NOT use InetAddress.getByName(..) here:
+        // the JDK may normalize it to an Inet4Address, yielding a 4-byte array.
+        final byte[] v6mapped = new byte[16];
+        v6mapped[10] = (byte) 0xff;
+        v6mapped[11] = (byte) 0xff;
+
+        final AddressSelectingDnsResolver.Network p96 =
+                new AddressSelectingDnsResolver.Network(v6mapped, 96);
+
+        assertTrue(p96.contains(inet("192.0.2.1")));
+        assertTrue(p96.contains(inet("203.0.113.10")));
+
+        // A pure IPv6 address must not match that v4-mapped prefix.
+        assertFalse(p96.contains(inet("2001:db8::1")));
+    }
+
+    @Test
+    void networkContains_nonByteAlignedPrefix7Boundary() throws Exception {
+        // fc00::/7 (ULA) is in the policy table.
+        final AddressSelectingDnsResolver.Network p7 =
+                new AddressSelectingDnsResolver.Network(inet("fc00::").getAddress(), 7);
+
+        // Inside /7: fc00:: and fd00:: (since /7 covers fc00..fdff)
+        assertTrue(p7.contains(inet("fc00::1")));
+        assertTrue(p7.contains(inet("fd00::1")));
+
+        // Just outside /7: fe00:: (top bits 11111110 vs 1111110x)
+        assertFalse(p7.contains(inet("fe00::1")));
+        assertFalse(p7.contains(inet("2001:db8::1")));
+    }
+
+}
\ No newline at end of file
diff --git a/httpclient5/src/test/java/org/apache/hc/client5/http/examples/AddressSelectingDnsResolverExample.java b/httpclient5/src/test/java/org/apache/hc/client5/http/examples/AddressSelectingDnsResolverExample.java
new file mode 100644
index 0000000000..a7c6656da7
--- /dev/null
+++ b/httpclient5/src/test/java/org/apache/hc/client5/http/examples/AddressSelectingDnsResolverExample.java
@@ -0,0 +1,79 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+
+package org.apache.hc.client5.http.examples;
+
+import java.net.InetAddress;
+
+import org.apache.hc.client5.http.DnsResolver;
+import org.apache.hc.client5.http.AddressSelectingDnsResolver;
+import org.apache.hc.client5.http.SystemDefaultDnsResolver;
+import org.apache.hc.client5.http.config.ProtocolFamilyPreference;
+
+public final class AddressSelectingDnsResolverExample {
+
+    public static void main(final String[] args) throws Exception {
+        final String host = args.length > 0 ? args[0] : "localhost";
+        final ProtocolFamilyPreference pref = args.length > 1
+                ? ProtocolFamilyPreference.valueOf(args[1])
+                : ProtocolFamilyPreference.DEFAULT;
+
+        System.out.println("Host: " + host);
+        System.out.println("Preference: " + pref);
+        System.out.println();
+
+        // Before: raw system resolver output (no RFC 6724 ordering).
+        final InetAddress[] raw = SystemDefaultDnsResolver.INSTANCE.resolve(host);
+        System.out.println("Before (system resolver):");
+        printAddresses(raw);
+
+        // After: RFC 6724 ordered + family preference applied.
+        final DnsResolver resolver = new AddressSelectingDnsResolver(SystemDefaultDnsResolver.INSTANCE, pref);
+        final InetAddress[] out = resolver.resolve(host);
+        System.out.println("After (AddressSelectingDnsResolver, " + pref + "):");
+        printAddresses(out);
+    }
+
+    private static void printAddresses(final InetAddress[] addresses) {
+        if (addresses == null) {
+            System.out.println("  null");
+            return;
+        }
+        if (addresses.length == 0) {
+            System.out.println("  []");
+            return;
+        }
+        for (final InetAddress a : addresses) {
+            final String family = a instanceof java.net.Inet6Address ? "IPv6" : "IPv4";
+            System.out.println("  " + family + " " + a.getHostAddress());
+        }
+        System.out.println();
+    }
+
+    private AddressSelectingDnsResolverExample() {
+    }
+}