diff --git a/src/libraries/Microsoft.Extensions.Configuration/ref/Microsoft.Extensions.Configuration.cs b/src/libraries/Microsoft.Extensions.Configuration/ref/Microsoft.Extensions.Configuration.cs
index 31de97acabf21a..ffcbf3c2995e81 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/ref/Microsoft.Extensions.Configuration.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration/ref/Microsoft.Extensions.Configuration.cs
@@ -97,16 +97,28 @@ public ConfigurationSection(Microsoft.Extensions.Configuration.IConfigurationRoo
         public string Key { get { throw null; } }
         public string Path { get { throw null; } }
         public string? Value { get { throw null; } set { } }
-        public bool TryGetValue(string? key, out string? value) { throw null; }
         public System.Collections.Generic.IEnumerable<Microsoft.Extensions.Configuration.IConfigurationSection> GetChildren() { throw null; }
         public Microsoft.Extensions.Primitives.IChangeToken GetReloadToken() { throw null; }
         public Microsoft.Extensions.Configuration.IConfigurationSection GetSection(string key) { throw null; }
+        public bool TryGetValue(string? key, out string? value) { throw null; }
     }
     public static partial class MemoryConfigurationBuilderExtensions
     {
         public static Microsoft.Extensions.Configuration.IConfigurationBuilder AddInMemoryCollection(this Microsoft.Extensions.Configuration.IConfigurationBuilder configurationBuilder) { throw null; }
         public static Microsoft.Extensions.Configuration.IConfigurationBuilder AddInMemoryCollection(this Microsoft.Extensions.Configuration.IConfigurationBuilder configurationBuilder, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, string?>>? initialData) { throw null; }
     }
+    public enum ReferenceMode
+    {
+        Ignore = 0,
+        Read = 1,
+        Scan = 2,
+    }
+    public static partial class ReferenceResolutionConfigurationBuilderExtensions
+    {
+        public static Microsoft.Extensions.Configuration.IConfigurationBuilder SetReferenceMode(this Microsoft.Extensions.Configuration.IConfigurationBuilder configurationBuilder, Microsoft.Extensions.Configuration.IConfigurationSource source, Microsoft.Extensions.Configuration.ReferenceMode mode) { throw null; }
+        public static Microsoft.Extensions.Configuration.IConfigurationBuilder SetReferenceMode(this Microsoft.Extensions.Configuration.IConfigurationBuilder configurationBuilder, Microsoft.Extensions.Configuration.ReferenceMode mode) { throw null; }
+        public static Microsoft.Extensions.Configuration.IConfigurationBuilder SetReferenceMode(this Microsoft.Extensions.Configuration.IConfigurationBuilder configurationBuilder, System.Collections.Generic.IEnumerable<Microsoft.Extensions.Configuration.IConfigurationSource> sources, Microsoft.Extensions.Configuration.ReferenceMode mode) { throw null; }
+    }
     public abstract partial class StreamConfigurationProvider : Microsoft.Extensions.Configuration.ConfigurationProvider
     {
         public StreamConfigurationProvider(Microsoft.Extensions.Configuration.StreamConfigurationSource source) { }
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationBuilder.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationBuilder.cs
index 75b930f60f16eb..18a5b4fa9a8b00 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationBuilder.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationBuilder.cs
@@ -47,10 +47,17 @@ public IConfigurationRoot Build()
             var providers = new List<IConfigurationProvider>();
             foreach (IConfigurationSource source in _sources)
             {
-                IConfigurationProvider provider = source.Build(this);
-                providers.Add(provider);
+                providers.Add(source.Build(this));
             }
-            return new ConfigurationRoot(providers);
+
+            ReferenceResolutionEngine? engine = null;
+            if (ReferenceResolutionConfigurationBuilderExtensions.HasAnyScanSource(Properties, _sources))
+            {
+                Dictionary<IConfigurationProvider, ReferenceMode>? providerModes = ReferenceResolutionConfigurationBuilderExtensions
+                    .ResolveProviderModes(Properties, _sources, providers);
+                engine = new ReferenceResolutionEngine(providers, providerModes);
+            }
+            return new ConfigurationRoot(providers, engine);
         }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationManager.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationManager.cs
index b31c4bb0c6392e..21ddcda1dd8de0 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationManager.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationManager.cs
@@ -37,6 +37,12 @@ public sealed class ConfigurationManager : IConfigurationManager, IConfiguration
         private readonly List<IDisposable> _changeTokenRegistrations = new();
         private ConfigurationReloadToken _changeToken = new();
 
+        // Non-null when the builder opted into reference resolution via EnableReferenceResolution.
+        // Rebuilt on every source mutation (AddSource/ReloadSources) so it always reflects the
+        // current provider set. Reads are unsynchronized; in-flight reads that observe a stale
+        // engine still see a consistent (old) provider snapshot held by that engine.
+        private ReferenceResolutionEngine? _engine;
+
         /// <summary>
         /// Creates an empty mutable configuration object that is both an <see cref="IConfigurationBuilder"/> and an <see cref="IConfigurationRoot"/>.
         /// </summary>
@@ -55,6 +61,12 @@ public string? this[string key]
             get
             {
                 using ReferenceCountedProviders reference = _providerManager.GetReference();
+                ReferenceResolutionEngine? engine = _engine;
+                if (engine is not null)
+                {
+                    return engine.TryGet(key, out string? resolved) ? resolved : null;
+                }
+
                 return ConfigurationRoot.GetConfiguration(reference.Providers, key);
             }
             set
@@ -64,6 +76,8 @@ public string? this[string key]
             }
         }
 
+        internal ReferenceResolutionEngine? Engine => _engine;
+
         /// <inheritdoc/>
         public IConfigurationSection GetSection(string key) => new ConfigurationSection(this, key);
 
@@ -84,6 +98,7 @@ public string? this[string key]
         public void Dispose()
         {
             DisposeRegistrations();
+            Interlocked.Exchange(ref _engine, null)?.Dispose();
             _providerManager.Dispose();
         }
 
@@ -109,6 +124,7 @@ void IConfigurationRoot.Reload()
                 }
             }
 
+            _engine?.Invalidate();
             RaiseChanged();
         }
 
@@ -129,6 +145,7 @@ private void AddSource(IConfigurationSource source)
             _changeTokenRegistrations.Add(ChangeToken.OnChange(provider.GetReloadToken, RaiseChanged));
 
             _providerManager.AddProvider(provider);
+            SwapEngine();
             RaiseChanged();
         }
 
@@ -153,9 +170,30 @@ private void ReloadSources()
             }
 
             _providerManager.ReplaceProviders(newProvidersList);
+            SwapEngine();
             RaiseChanged();
         }
 
+        // Rebuild the engine against the current provider set when resolution is enabled.
+        // The old engine's providers are the previous snapshot, and any in-flight read that
+        // already captured the old engine will complete against that snapshot; a subsequent
+        // read will pick up the new engine. The old engine is disposed to drop its reload-
+        // token subscription against the old providers.
+        private void SwapEngine()
+        {
+            ReferenceResolutionEngine? newEngine = null;
+            if (ReferenceResolutionConfigurationBuilderExtensions.HasAnyScanSource(_properties.Raw, _sources))
+            {
+                IReadOnlyList<IConfigurationProvider> providers = _providerManager.GetProvidersSnapshot();
+                Dictionary<IConfigurationProvider, ReferenceMode>? providerModes = ReferenceResolutionConfigurationBuilderExtensions
+                    .ResolveProviderModes(_properties.Raw, _sources, providers);
+                newEngine = new ReferenceResolutionEngine(providers, providerModes);
+            }
+
+            ReferenceResolutionEngine? previous = Interlocked.Exchange(ref _engine, newEngine);
+            previous?.Dispose();
+        }
+
         private void DisposeRegistrations()
         {
             // dispose change token registrations
@@ -276,7 +314,14 @@ public object this[string key]
                 set
                 {
                     _properties[key] = value;
-                    _config.ReloadSources();
+                    if (IsReferenceResolutionProperty(key))
+                    {
+                        _config.SwapEngine();
+                    }
+                    else
+                    {
+                        _config.ReloadSources();
+                    }
                 }
             }
 
@@ -291,13 +336,27 @@ public object this[string key]
             public void Add(string key, object value)
             {
                 _properties.Add(key, value);
-                _config.ReloadSources();
+                if (IsReferenceResolutionProperty(key))
+                {
+                    _config.SwapEngine();
+                }
+                else
+                {
+                    _config.ReloadSources();
+                }
             }
 
             public void Add(KeyValuePair<string, object> item)
             {
                 ((IDictionary<string, object>)_properties).Add(item);
-                _config.ReloadSources();
+                if (IsReferenceResolutionProperty(item.Key))
+                {
+                    _config.SwapEngine();
+                }
+                else
+                {
+                    _config.ReloadSources();
+                }
             }
 
             public void Clear()
@@ -329,17 +388,43 @@ public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
             public bool Remove(string key)
             {
                 var wasRemoved = _properties.Remove(key);
-                _config.ReloadSources();
+                if (IsReferenceResolutionProperty(key))
+                {
+                    _config.SwapEngine();
+                }
+                else
+                {
+                    _config.ReloadSources();
+                }
+
                 return wasRemoved;
             }
 
             public bool Remove(KeyValuePair<string, object> item)
             {
                 var wasRemoved = ((IDictionary<string, object>)_properties).Remove(item);
-                _config.ReloadSources();
+                if (IsReferenceResolutionProperty(item.Key))
+                {
+                    _config.SwapEngine();
+                }
+                else
+                {
+                    _config.ReloadSources();
+                }
+
                 return wasRemoved;
             }
 
+            // Reference-resolution property writes only affect how the root interprets the existing
+            // provider set; they never change which providers exist or what they hold. Handling them
+            // through SwapEngine avoids the O(n) provider rebuild/Load cost that a general property
+            // write triggers via ReloadSources, so enabling or reconfiguring resolution mid-setup
+            // does not penalize callers using slow-to-load sources (e.g. Azure App Configuration).
+            private static bool IsReferenceResolutionProperty(string key)
+            {
+                return key == ReferenceResolutionConfigurationBuilderExtensions.SourceModesPropertyName;
+            }
+
             public bool TryGetValue(string key, [NotNullWhen(true)] out object? value)
             {
                 return _properties.TryGetValue(key, out value);
@@ -349,6 +434,11 @@ IEnumerator IEnumerable.GetEnumerator()
             {
                 return _properties.GetEnumerator();
             }
+
+            // Direct accessor used by the ConfigurationManager build/reload loop to mutate
+            // well-known properties (e.g. PreviouslyBuiltProviders) without triggering another
+            // ReloadSources via the IDictionary interface this class exposes publicly.
+            internal IDictionary<string, object> Raw => _properties;
         }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationRoot.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationRoot.cs
index bd53b747a43822..d260a11c643965 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationRoot.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationRoot.cs
@@ -17,6 +17,7 @@ namespace Microsoft.Extensions.Configuration
     public class ConfigurationRoot : IConfigurationRoot, IDisposable
     {
         private readonly IList<IConfigurationProvider> _providers;
+        private readonly ReferenceResolutionEngine? _engine;
         private readonly List<IDisposable> _changeTokenRegistrations;
         private ConfigurationReloadToken _changeToken = new ConfigurationReloadToken();
 
@@ -25,10 +26,16 @@ public class ConfigurationRoot : IConfigurationRoot, IDisposable
         /// </summary>
         /// <param name="providers">The <see cref="IConfigurationProvider"/>s for this configuration.</param>
         public ConfigurationRoot(IList<IConfigurationProvider> providers)
+            : this(providers, engine: null)
+        {
+        }
+
+        internal ConfigurationRoot(IList<IConfigurationProvider> providers, ReferenceResolutionEngine? engine)
         {
             ArgumentNullException.ThrowIfNull(providers);
 
             _providers = providers;
+            _engine = engine;
             _changeTokenRegistrations = new List<IDisposable>(providers.Count);
             foreach (IConfigurationProvider p in providers)
             {
@@ -42,6 +49,8 @@ public ConfigurationRoot(IList<IConfigurationProvider> providers)
         /// </summary>
         public IEnumerable<IConfigurationProvider> Providers => _providers;
 
+        internal ReferenceResolutionEngine? Engine => _engine;
+
         /// <summary>
         /// Gets or sets the value corresponding to a configuration key.
         /// </summary>
@@ -49,7 +58,15 @@ public ConfigurationRoot(IList<IConfigurationProvider> providers)
         /// <returns>The configuration value.</returns>
         public string? this[string key]
         {
-            get => GetConfiguration(_providers, key);
+            get
+            {
+                if (_engine is not null)
+                {
+                    return _engine.TryGet(key, out string? resolved) ? resolved : null;
+                }
+
+                return GetConfiguration(_providers, key);
+            }
             set => SetConfiguration(_providers, key, value);
         }
 
@@ -86,6 +103,7 @@ public void Reload()
             {
                 provider.Load();
             }
+            _engine?.Invalidate();
             RaiseChanged();
         }
 
@@ -109,6 +127,8 @@ public void Dispose()
             {
                 (provider as IDisposable)?.Dispose();
             }
+
+            _engine?.Dispose();
         }
 
         internal static string? GetConfiguration(IList<IConfigurationProvider> providers, string key)
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/InternalConfigurationRootExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration/src/InternalConfigurationRootExtensions.cs
index a4a57d45d59930..0666b0b8947409 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/src/InternalConfigurationRootExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/InternalConfigurationRootExtensions.cs
@@ -23,9 +23,17 @@ internal static IEnumerable<IConfigurationSection> GetChildrenImplementation(thi
             using ReferenceCountedProviders? reference = (root as ConfigurationManager)?.GetProvidersReference();
             IEnumerable<IConfigurationProvider> providers = reference?.Providers ?? root.Providers;
 
-            IEnumerable<IConfigurationSection> children = providers
+            IEnumerable<string> keys = providers
                 .Aggregate(Enumerable.Empty<string>(),
-                    (seed, source) => source.GetChildKeys(seed, path))
+                    (seed, source) => source.GetChildKeys(seed, path));
+
+            ReferenceResolutionEngine? engine = (root as ConfigurationRoot)?.Engine ?? (root as ConfigurationManager)?.Engine;
+            if (engine is not null)
+            {
+                keys = engine.GetChildKeys(keys, path);
+            }
+
+            IEnumerable<IConfigurationSection> children = keys
                 .Distinct(StringComparer.OrdinalIgnoreCase)
                 .Select(key => root.GetSection(path == null ? key : path + ConfigurationPath.KeyDelimiter + key));
 
@@ -42,6 +50,18 @@ internal static IEnumerable<IConfigurationSection> GetChildrenImplementation(thi
 
         internal static bool TryGetConfiguration(this IConfigurationRoot root, string key, out string? value)
         {
+            ReferenceResolutionEngine? engine = (root as ConfigurationRoot)?.Engine ?? (root as ConfigurationManager)?.Engine;
+            if (engine is not null)
+            {
+                if (engine.TryGet(key, out value))
+                {
+                    return true;
+                }
+
+                value = null;
+                return false;
+            }
+
             // common cases Providers is IList<IConfigurationProvider> in ConfigurationRoot
             IList<IConfigurationProvider> providers = root.Providers is IList<IConfigurationProvider> list
                 ? list
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceCountedProvidersManager.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceCountedProvidersManager.cs
index 210e41f665a47a..70f3fa8ed2702e 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceCountedProvidersManager.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceCountedProvidersManager.cs
@@ -75,6 +75,22 @@ public void AddProvider(IConfigurationProvider provider)
             }
         }
 
+        // Returns an immutable snapshot of the currently-built providers. Used by the builder's
+        // source.Build(...) loop so a ReferenceResolutionConfigurationSource can observe providers
+        // registered before it.
+        public IReadOnlyList<IConfigurationProvider> GetProvidersSnapshot()
+        {
+            lock (_replaceProvidersLock)
+            {
+                if (_disposed)
+                {
+                    throw new ObjectDisposedException(nameof(ConfigurationManager));
+                }
+
+                return _refCountedProviders.Providers.ToArray();
+            }
+        }
+
         public void Dispose()
         {
             ReferenceCountedProviders oldRefCountedProviders = _refCountedProviders;
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceMode.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceMode.cs
new file mode 100644
index 00000000000000..514ce194ae7950
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceMode.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Extensions.Configuration
+{
+    /// <summary>
+    /// Controls how an <see cref="IConfigurationSource"/> participates in <c>{{…}}</c>
+    /// reference resolution performed by the <see cref="IConfigurationRoot"/> built from the
+    /// containing <see cref="IConfigurationBuilder"/>.
+    /// </summary>
+    /// <remarks>
+    /// Values are totally ordered by participation: <see cref="Ignore"/> &lt; <see cref="Read"/>
+    /// &lt; <see cref="Scan"/>. Sources default to <see cref="Read"/> unless configured via
+    /// <see cref="ReferenceResolutionConfigurationBuilderExtensions.SetReferenceMode(IConfigurationBuilder, ReferenceMode)"/>
+    /// or one of its overloads. The reference-resolution engine is attached to the built root
+    /// only when at least one source has been explicitly marked <see cref="Scan"/>.
+    /// </remarks>
+    public enum ReferenceMode
+    {
+        /// <summary>
+        /// The source is invisible to the reference-resolution engine: no <c>{{…}}</c>
+        /// reference or section alias in another source can reach its values. Direct reads
+        /// via the normal <see cref="IConfiguration"/> API still return its values.
+        /// </summary>
+        Ignore = 0,
+
+        /// <summary>
+        /// The source is a valid substitution target for references in other
+        /// <see cref="Scan"/> sources. The source's own values are returned verbatim —
+        /// <c>ref(...)</c> / <c>format(...)</c> sequences are not interpreted. This is
+        /// the default mode for sources that have not been configured explicitly.
+        /// </summary>
+        Read = 1,
+
+        /// <summary>
+        /// The source's values are scanned for <c>ref(...)</c> / <c>format(...)</c> tokens
+        /// and section aliases, and the source is exposed as a substitution target for
+        /// other <see cref="Scan"/> sources. Marking at least one source with this value
+        /// activates the reference-resolution engine.
+        /// </summary>
+        Scan = 2,
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceParser.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceParser.cs
new file mode 100644
index 00000000000000..3dee543019b4f9
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceParser.cs
@@ -0,0 +1,781 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.Extensions.Configuration
+{
+    // Value syntax:
+    //   ref(<chain>)         — reference; may resolve to a section.
+    //   format(<template>)   — string template.
+    //   any other value      — verbatim literal.
+    //
+    // chain (inside ref(...) and inside `{...}` placeholders):
+    //   member ('?' member)* ('??' default)?
+    //   - '?' separates member lookups (left-to-right; first existing wins).
+    //   - '??' (double question mark) introduces a single trailing default. The default body
+    //     uses template grammar (literal text + `{<chain>}` placeholders + `{{`/`}}` brace
+    //     escapes). A '??' with no body means empty-string default.
+    //   - At least one member is required before '??'.
+    //   - An empty chain (`ref()`) is a parse error.
+    //   - A bare trailing single '?' (no second '?') is a parse error: use '??' for empty default.
+    //
+    // member:
+    //   - Unquoted: a path. Use ':' (or '.') to separate segments. Use '..' segments to walk
+    //     up from the value's own section. Reserved characters (`?`, `(`, `)`, `'`, `"`,
+    //     `{`, `}`, whitespace) cannot appear in an unquoted path — use a quoted member to
+    //     embed them. Surrounding whitespace is trimmed.
+    //   - Quoted: `'…'` or `"…"`. The body is a single literal key — no ':' splitting. The
+    //     same quote char doubled inside the body escapes itself (e.g. `'it''s'` → `it's`).
+    //
+    // default (after '??'):
+    //   - Unquoted: leading and trailing whitespace are trimmed; the trimmed body is parsed
+    //     as a template.
+    //   - Quoted: `'…'` or `"…"`. The body is preserved verbatim (whitespace included);
+    //     doubled-quote inside escapes itself; the body is then parsed as a template.
+    //
+    // template (inside format(...) and after '??' inside a chain):
+    //   Verbatim text with embedded {<chain>} placeholders.
+    //   - `{{` emits a literal `{`; `}}` emits a literal `}` (composite-format-style doubling).
+    //   - A single `{` opens a placeholder; the matching `}` closes it. The content is a
+    //     chain (same grammar as inside ref(...)). Embedded placeholders MUST resolve to a
+    //     scalar value; resolving to a section throws at resolution time.
+    //   - All other characters are verbatim.
+    //
+    // format(...) body wrapping:
+    //   - Unquoted: leading and trailing whitespace are trimmed before template parsing.
+    //   - Quoted: `'…'` or `"…"`. The body is preserved verbatim (whitespace included);
+    //     doubled-quote inside escapes itself; the body is then parsed as a template.
+    //
+    // Sections:
+    //   At the top level, ref(<chain>) may resolve to a section (alias). Sections
+    //   are always strict — earlier-provider keys are not merged under the alias path.
+    //   Embedded `{...}` placeholders inside format(...) MUST resolve to a scalar value.
+    internal static class ReferenceParser
+    {
+        private const string RefOpen = "ref(";
+        private const string FormatOpen = "format(";
+
+        internal static bool ContainsReference(string? value)
+        {
+            if (value is null)
+            {
+                return false;
+            }
+
+            return StartsWith(value, RefOpen)
+                || StartsWith(value, FormatOpen);
+        }
+
+        internal static ValueToken Parse(string value)
+        {
+            ArgumentNullException.ThrowIfNull(value);
+
+            if (StartsWith(value, RefOpen))
+            {
+                return ParseRef(value, openParenIndex: 3, tokenStart: 0);
+            }
+
+            if (StartsWith(value, FormatOpen))
+            {
+                return ParseFormat(value, openParenIndex: 6, tokenStart: 0);
+            }
+
+            return ValueToken.Literal(value);
+        }
+
+        private static bool StartsWith(string value, string prefix) =>
+            value.Length >= prefix.Length && value.AsSpan(0, prefix.Length).SequenceEqual(prefix.AsSpan());
+
+        // Parse a top-level (or chain-default) ref(<chain>) call. `openParenIndex` is the index
+        // of the '('; the matching ')' must be the last character of `value` (we don't allow
+        // trailing content after the close).
+        private static ValueToken ParseRef(string value, int openParenIndex, int tokenStart)
+        {
+            int closeIndex = FindMatchingClose(value, openParenIndex, tokenStart);
+            if (closeIndex != value.Length - 1)
+            {
+                throw new FormatException(
+                    SR.Format(SR.ReferenceResolution_TrailingContentAfterClose, tokenStart + closeIndex + 1));
+            }
+
+            string content = value.Substring(openParenIndex + 1, closeIndex - openParenIndex - 1);
+            return ParseChain(content, contentStart: tokenStart + openParenIndex + 1);
+        }
+
+        // Parse a top-level (or chain-default) format(<template>) call.
+        private static ValueToken ParseFormat(string value, int openParenIndex, int tokenStart)
+        {
+            int closeIndex = FindMatchingClose(value, openParenIndex, tokenStart);
+            if (closeIndex != value.Length - 1)
+            {
+                throw new FormatException(
+                    SR.Format(SR.ReferenceResolution_TrailingContentAfterClose, tokenStart + closeIndex + 1));
+            }
+
+            int bodyStart = openParenIndex + 1;
+            int bodyEnd = closeIndex;
+            int contentStart = tokenStart;
+
+            ParseTrimmableTemplateBody(value, bodyStart, bodyEnd, contentStart, out IReadOnlyList<ValueToken> tokens);
+            return ValueToken.Format(tokens);
+        }
+
+        // Apply trim-or-quote logic shared by format(...) bodies and chain defaults.
+        // - If body (after skipping leading whitespace) starts with a quote, the entire body
+        //   must be a single quoted string (whitespace allowed before/after quotes only); the
+        //   quoted text is preserved verbatim.
+        // - Otherwise, leading and trailing whitespace are trimmed.
+        // The resulting body is parsed as a template.
+        private static void ParseTrimmableTemplateBody(
+            string content,
+            int bodyStart,
+            int bodyEnd,
+            int contentStart,
+            out IReadOnlyList<ValueToken> tokens)
+        {
+            int i = bodyStart;
+            while (i < bodyEnd && IsWhite(content[i]))
+            {
+                i++;
+            }
+
+            if (i < bodyEnd && (content[i] == '\'' || content[i] == '"'))
+            {
+                int quoteStart = i;
+                string body = ScanQuotedBody(content, ref i, contentStart);
+
+                while (i < bodyEnd && IsWhite(content[i]))
+                {
+                    i++;
+                }
+
+                if (i < bodyEnd)
+                {
+                    throw new FormatException(SR.Format(SR.ReferenceResolution_TrailingContentAfterQuotedDefault, contentStart + i));
+                }
+
+                // Use the position just past the opening quote as the diagnostic base. Doubled
+                // quote escapes inside the body may shift offsets by ±1 per occurrence.
+                tokens = ParseTemplate(body, templateStart: contentStart + quoteStart + 1);
+                return;
+            }
+
+            int unquotedStart = i;
+            int unquotedEnd = bodyEnd;
+            while (unquotedEnd > unquotedStart && IsWhite(content[unquotedEnd - 1]))
+            {
+                unquotedEnd--;
+            }
+
+            string unquoted = unquotedStart >= unquotedEnd
+                ? string.Empty
+                : content.Substring(unquotedStart, unquotedEnd - unquotedStart);
+            tokens = ParseTemplate(unquoted, templateStart: contentStart + unquotedStart);
+        }
+
+        // Find the ')' that matches the '(' at openParenIndex. Tracks nested parens and skips
+        // over quoted regions ('...' or "...") so a `)` inside a quoted chain member is literal.
+        private static int FindMatchingClose(string value, int openParenIndex, int tokenStart)
+        {
+            int depth = 1;
+            int i = openParenIndex + 1;
+            while (i < value.Length)
+            {
+                char c = value[i];
+
+                if (c == '\'' || c == '"')
+                {
+                    i = SkipQuoted(value, i, tokenStart);
+                    continue;
+                }
+
+                if (c == '(')
+                {
+                    depth++;
+                    i++;
+                    continue;
+                }
+
+                if (c == ')')
+                {
+                    depth--;
+                    if (depth == 0)
+                    {
+                        return i;
+                    }
+                    i++;
+                    continue;
+                }
+
+                i++;
+            }
+
+            throw new FormatException(SR.Format(SR.ReferenceResolution_ExpressionIsUnclosed, tokenStart + openParenIndex));
+        }
+
+        // Advances past a quoted region starting at i (which must be at the opening quote).
+        // Returns the index just past the closing quote. Doubled quote chars are part of the
+        // body. Throws on unterminated quote.
+        private static int SkipQuoted(string s, int i, int tokenStart)
+        {
+            char q = s[i];
+            int openPos = i;
+            i++;
+            while (i < s.Length)
+            {
+                char c = s[i];
+                if (c == q)
+                {
+                    if (i + 1 < s.Length && s[i + 1] == q)
+                    {
+                        i += 2;
+                        continue;
+                    }
+                    return i + 1;
+                }
+                i++;
+            }
+            throw new FormatException(SR.Format(SR.ReferenceResolution_UnterminatedQuote, tokenStart + openPos));
+        }
+
+        // Scans a quoted member starting at content[i] (must be a quote). On success returns
+        // the unescaped body and advances i past the closing quote.
+        private static string ScanQuotedBody(string content, ref int i, int contentStart)
+        {
+            char q = content[i];
+            int openPos = i;
+            i++;
+            var sb = new StringBuilder();
+            while (i < content.Length)
+            {
+                char c = content[i];
+                if (c == q)
+                {
+                    if (i + 1 < content.Length && content[i + 1] == q)
+                    {
+                        sb.Append(q);
+                        i += 2;
+                        continue;
+                    }
+                    i++;
+                    return sb.ToString();
+                }
+                sb.Append(c);
+                i++;
+            }
+            throw new FormatException(SR.Format(SR.ReferenceResolution_UnterminatedQuote, contentStart + openPos));
+        }
+
+        // Parse the chain content between ref's parens. `content` is the substring; `contentStart`
+        // is its absolute offset for diagnostic positions.
+        private static ValueToken ParseChain(string content, int contentStart)
+        {
+            // Empty chain: ref() → error. We only reject all-whitespace here; we DO NOT trim
+            // the content overall, because trailing whitespace after '??' is part of the
+            // default-template body and must be preserved.
+            int leadingWhite = 0;
+            while (leadingWhite < content.Length && IsWhite(content[leadingWhite]))
+            {
+                leadingWhite++;
+            }
+            if (leadingWhite == content.Length)
+            {
+                throw new FormatException(SR.Format(SR.ReferenceResolution_ExpressionIsEmpty, contentStart));
+            }
+
+            var paths = new List<ReferenceItem>();
+            IReadOnlyList<ValueToken>? defaultTokens = null;
+            bool hasEmptyDefault = false;
+
+            int i = leadingWhite;
+            int end = content.Length;
+
+            while (i < end)
+            {
+                // Skip leading whitespace before a path member.
+                while (i < end && IsWhite(content[i]))
+                {
+                    i++;
+                }
+
+                if (i >= end)
+                {
+                    // Trailing single '?' (no second '?'): error — '??' is required for empty default.
+                    throw new FormatException(SR.Format(SR.ReferenceResolution_KeyIsEmpty, contentStart + i));
+                }
+
+                if (content[i] == '?')
+                {
+                    // Leading '?' or '??' before any path member: at least one path is required.
+                    throw new FormatException(SR.Format(SR.ReferenceResolution_KeyIsEmpty, contentStart + i));
+                }
+
+                if (content[i] == '\'' || content[i] == '"')
+                {
+                    // Quoted key member: body is the literal key (no ':' splitting, no '\' escape;
+                    // the doubled-quote escape consumed by ScanQuotedBody is the only special form).
+                    int quoteStart = i;
+                    string quotedBody = ScanQuotedBody(content, ref i, contentStart);
+                    if (quotedBody.Length == 0)
+                    {
+                        throw new FormatException(SR.Format(SR.ReferenceResolution_KeyIsEmpty, contentStart + quoteStart));
+                    }
+                    paths.Add(new ReferenceItem(quotedBody, parentHops: 0));
+                }
+                else
+                {
+                    // Unquoted path member: scan until '?'. Reserved characters cannot appear
+                    // in an unquoted path; use a quoted member ('…' / "…") to embed them.
+                    int pathStart = i;
+                    while (i < end)
+                    {
+                        char ch = content[i];
+                        if (ch == '?')
+                        {
+                            break;
+                        }
+                        i++;
+                    }
+
+                    int rawStart = pathStart;
+                    int rawEnd = i;
+                    while (rawEnd > rawStart && IsWhite(content[rawEnd - 1]))
+                    {
+                        rawEnd--;
+                    }
+
+                    if (rawEnd == rawStart)
+                    {
+                        throw new FormatException(SR.Format(SR.ReferenceResolution_KeyIsEmpty, contentStart + pathStart));
+                    }
+
+                    ReferenceItem item = ParsePath(content, rawStart, rawEnd, contentStart + rawStart);
+                    paths.Add(item);
+                }
+
+                // Allow whitespace between a member (especially a quoted one) and the next separator.
+                while (i < end && IsWhite(content[i]))
+                {
+                    i++;
+                }
+
+                if (i >= end)
+                {
+                    break;
+                }
+
+                // content[i] should be '?' here. Anything else (e.g., extra content after a
+                // quoted member) is malformed.
+                if (content[i] != '?')
+                {
+                    throw new FormatException(SR.Format(SR.ReferenceResolution_InvalidExpression, contentStart + i));
+                }
+
+                // Check for '??' (default introducer).
+                if (i + 1 < end && content[i + 1] == '?')
+                {
+                    int defaultBodyStart = i + 2;
+                    ParseDefaultBody(content, defaultBodyStart, end, contentStart, out defaultTokens, out hasEmptyDefault);
+                    break;
+                }
+
+                // Single '?' separator → continue to next path. Track the position of this
+                // separator so we can report a clear error if the chain ends here (a bare
+                // trailing single '?' is not a valid chain — '??' is required for an empty default).
+                int separatorPos = i;
+                i++;
+                if (i >= end)
+                {
+                    throw new FormatException(SR.Format(SR.ReferenceResolution_KeyIsEmpty, contentStart + separatorPos));
+                }
+            }
+
+            return ValueToken.Reference(paths, defaultTokens, hasEmptyDefault);
+        }
+
+        // Parse the default-template body that follows '??'. May be quoted (preserves verbatim
+        // body, including leading/trailing whitespace; doubled-quote escapes the quote char) or
+        // Parse a chain default body into a token sequence. Defaults to a trimmed unquoted body
+        // unless quoted (`'…'` or `"…"`), in which case the body is preserved verbatim. Either
+        // way, the body is then parsed as a composite-format template ({...} placeholders +
+        // {{ }} brace escapes).
+        private static void ParseDefaultBody(
+            string content,
+            int bodyStart,
+            int end,
+            int contentStart,
+            out IReadOnlyList<ValueToken>? defaultTokens,
+            out bool hasEmptyDefault)
+        {
+            ParseTrimmableTemplateBody(content, bodyStart, end, contentStart, out IReadOnlyList<ValueToken> tokens);
+            if (tokens.Count == 0)
+            {
+                defaultTokens = null;
+                hasEmptyDefault = true;
+            }
+            else
+            {
+                defaultTokens = tokens;
+                hasEmptyDefault = false;
+            }
+        }
+
+        // Parse a path member from content[rawStart..rawEnd). Honors leading '..' segments.
+        // Returns a ReferenceItem with the suffix (':' delimited) and parent hop count.
+        private static ReferenceItem ParsePath(string content, int rawStart, int rawEnd, int tokenStart)
+        {
+            // Count leading '..' (followed by ':' or '.' or end) for parent hops.
+            int parentHops = 0;
+            int cursor = rawStart;
+            while (cursor + 2 <= rawEnd && content[cursor] == '.' && content[cursor + 1] == '.')
+            {
+                int next = cursor + 2;
+                if (next == rawEnd)
+                {
+                    parentHops++;
+                    cursor = next;
+                    break;
+                }
+
+                char sep = content[next];
+                if (sep != ':' && sep != '.')
+                {
+                    break;
+                }
+
+                parentHops++;
+                cursor = next + 1;
+            }
+
+            string suffix = BuildPathSuffix(content, cursor, rawEnd, tokenStart);
+
+            if (parentHops == 0 && suffix.Length == 0)
+            {
+                throw new FormatException(SR.Format(SR.ReferenceResolution_KeyIsEmpty, tokenStart));
+            }
+
+            return new ReferenceItem(suffix, parentHops);
+        }
+
+        // Build the post-parent-hops portion of a path: split on ':' or '.', normalize to
+        // ConfigurationPath.KeyDelimiter.
+        private static string BuildPathSuffix(string content, int start, int end, int tokenStart)
+        {
+            if (start >= end)
+            {
+                return string.Empty;
+            }
+
+            var result = new StringBuilder();
+            var segment = new StringBuilder();
+            int i = start;
+
+            while (i < end)
+            {
+                char c = content[i];
+
+                if (c == ':' || c == '.')
+                {
+                    // '..' segments are only valid as a leading parent-hop marker (consumed in
+                    // ParsePath before BuildPathSuffix runs). Detect a mid-path '..' as a '.'
+                    // with an empty current segment whose next char is also '.'.
+                    if (c == '.' && segment.Length == 0 && i + 1 < end && content[i + 1] == '.')
+                    {
+                        throw new FormatException(SR.Format(SR.ReferenceResolution_InvalidExpression, tokenStart + i));
+                    }
+
+                    string seg = segment.ToString();
+                    AppendSegment(result, seg, tokenStart + i);
+                    segment.Clear();
+                    i++;
+                    continue;
+                }
+
+                segment.Append(c);
+                i++;
+            }
+
+            string lastSeg = segment.ToString();
+            AppendSegment(result, lastSeg, tokenStart + end);
+
+            return result.ToString();
+        }
+
+        private static void AppendSegment(StringBuilder result, string segment, int tokenStart)
+        {
+            if (segment == "..")
+            {
+                // '..' is only valid as a leading parent-hop marker, not in the middle of a path.
+                throw new FormatException(SR.Format(SR.ReferenceResolution_InvalidExpression, tokenStart));
+            }
+
+            if (result.Length > 0)
+            {
+                result.Append(ConfigurationPath.KeyDelimiter[0]);
+            }
+
+            result.Append(segment);
+        }
+
+        // Parse a format(<template>) body into a sequence of Literal/Reference tokens.
+        // - `{{` and `}}` are composite-format-style escapes for literal `{` and `}`.
+        // - A single `{` opens a placeholder whose content is a chain (same grammar as
+        //   inside ref(...)); the matching `}` closes it.
+        // - All other characters are verbatim.
+        private static List<ValueToken> ParseTemplate(string template, int templateStart)
+        {
+            var tokens = new List<ValueToken>();
+            var literal = new StringBuilder();
+
+            int i = 0;
+            while (i < template.Length)
+            {
+                char c = template[i];
+
+                if (c == '{')
+                {
+                    // `{{` → literal `{`.
+                    if (i + 1 < template.Length && template[i + 1] == '{')
+                    {
+                        literal.Append('{');
+                        i += 2;
+                        continue;
+                    }
+
+                    if (literal.Length > 0)
+                    {
+                        tokens.Add(ValueToken.Literal(literal.ToString()));
+                        literal.Clear();
+                    }
+
+                    int braceClose = FindMatchingBrace(template, i, templateStart + i);
+                    string content = template.Substring(i + 1, braceClose - i - 1);
+                    ValueToken refToken = ParseChain(content, contentStart: templateStart + i + 1);
+                    tokens.Add(refToken);
+                    i = braceClose + 1;
+                    continue;
+                }
+
+                if (c == '}')
+                {
+                    // `}}` → literal `}`. A bare `}` is an error: unbalanced placeholder close.
+                    if (i + 1 < template.Length && template[i + 1] == '}')
+                    {
+                        literal.Append('}');
+                        i += 2;
+                        continue;
+                    }
+
+                    throw new FormatException(SR.Format(SR.ReferenceResolution_InvalidExpression, templateStart + i));
+                }
+
+                literal.Append(c);
+                i++;
+            }
+
+            if (literal.Length > 0)
+            {
+                tokens.Add(ValueToken.Literal(literal.ToString()));
+            }
+
+            if (tokens.Count == 0)
+            {
+                tokens.Add(ValueToken.Literal(string.Empty));
+            }
+
+            return tokens;
+        }
+
+        // Find the `}` that matches the `{` at openIndex within a format template.
+        // Inside a placeholder body the grammar is a CHAIN: paths separated by '?',
+        // optionally followed by '??' which switches the rest of that level into TEMPLATE
+        // mode (where '{{' / '}}' are escapes for literal '{' / '}'). Nested '{...}'
+        // placeholders push a fresh chain scope.
+        private static int FindMatchingBrace(string template, int openIndex, int tokenStart)
+        {
+            // templateModeStack[top] == false → currently in path-part of the chain at this depth.
+            // templateModeStack[top] == true  → past '??' at this depth, in template-part.
+            var templateMode = new Stack<bool>();
+            templateMode.Push(false);
+            int i = openIndex + 1;
+
+            while (i < template.Length)
+            {
+                char c = template[i];
+
+                if (c == '\'' || c == '"')
+                {
+                    // Quoted region (member or default body) — skip opaquely so any '{', '}',
+                    // '?' or paren inside is literal at this lexer level.
+                    i = SkipQuoted(template, i, tokenStart);
+                    continue;
+                }
+
+                bool inTemplate = templateMode.Peek();
+
+                if (inTemplate)
+                {
+                    // `{{` → literal `{`.
+                    if (c == '{' && i + 1 < template.Length && template[i + 1] == '{')
+                    {
+                        i += 2;
+                        continue;
+                    }
+                    // `}}` → literal `}`.
+                    if (c == '}' && i + 1 < template.Length && template[i + 1] == '}')
+                    {
+                        i += 2;
+                        continue;
+                    }
+                }
+                else if (c == '?'
+                    && i + 1 < template.Length
+                    && template[i + 1] == '?')
+                {
+                    // First '??' at this depth: switch to template-part for the remainder
+                    // of this chain level.
+                    templateMode.Pop();
+                    templateMode.Push(true);
+                    i += 2;
+                    continue;
+                }
+
+                if (c == '{')
+                {
+                    templateMode.Push(false);
+                    i++;
+                    continue;
+                }
+
+                if (c == '}')
+                {
+                    templateMode.Pop();
+                    if (templateMode.Count == 0)
+                    {
+                        return i;
+                    }
+                    i++;
+                    continue;
+                }
+
+                i++;
+            }
+
+            throw new FormatException(SR.Format(SR.ReferenceResolution_ExpressionIsUnclosed, tokenStart));
+        }
+
+        private static int TrimWhitespace(string s, out int start, out int end)
+        {
+            start = 0;
+            end = s.Length;
+            while (start < end && IsWhite(s[start]))
+            {
+                start++;
+            }
+            while (end > start && IsWhite(s[end - 1]))
+            {
+                end--;
+            }
+            return end - start;
+        }
+
+        private static int SkipWhite(string s, int i, int end)
+        {
+            while (i < end && IsWhite(s[i]))
+            {
+                i++;
+            }
+            return i;
+        }
+
+        private static bool IsWhite(char c) => c == ' ' || c == '\t' || c == '\r' || c == '\n';
+    }
+
+    internal enum ValueTokenKind
+    {
+        Literal,
+        Reference,
+        Format,
+    }
+
+    internal readonly struct ReferenceItem
+    {
+        public ReferenceItem(string path, int parentHops = 0)
+        {
+            Value = path;
+            ParentHops = parentHops;
+        }
+
+        internal string Value { get; }
+
+        internal int ParentHops { get; }
+    }
+
+    internal readonly struct ValueToken
+    {
+        private static readonly IReadOnlyList<ReferenceItem> s_noItems = Array.Empty<ReferenceItem>();
+        private static readonly IReadOnlyList<ValueToken> s_noTokens = Array.Empty<ValueToken>();
+
+        private ValueToken(
+            ValueTokenKind kind,
+            string value,
+            IReadOnlyList<ReferenceItem> items,
+            IReadOnlyList<ValueToken>? @default,
+            bool hasEmptyDefault,
+            IReadOnlyList<ValueToken> tokens)
+        {
+            Kind = kind;
+            Value = value;
+            Items = items;
+            Default = @default;
+            HasEmptyDefault = hasEmptyDefault;
+            Tokens = tokens;
+        }
+
+        internal static ValueToken Literal(string text) =>
+            new(ValueTokenKind.Literal, text, s_noItems, @default: null, hasEmptyDefault: false, s_noTokens);
+
+        internal static ValueToken Reference(
+            IReadOnlyList<ReferenceItem> items,
+            IReadOnlyList<ValueToken>? @default,
+            bool hasEmptyDefault)
+        {
+            string first = items.Count > 0 ? items[0].Value : string.Empty;
+            return new ValueToken(ValueTokenKind.Reference, first, items, @default, hasEmptyDefault, s_noTokens);
+        }
+
+        internal static ValueToken Format(IReadOnlyList<ValueToken> tokens) =>
+            new(ValueTokenKind.Format, string.Empty, s_noItems, @default: null, hasEmptyDefault: false, tokens);
+
+        internal ValueTokenKind Kind { get; }
+
+        // For Literal tokens: the literal text.
+        // For Reference tokens: the first chain path's textual value (convenience for diagnostics).
+        // For Format tokens: empty.
+        internal string Value { get; }
+
+        // Reference: chain path members in left-to-right coalesce order.
+        internal IReadOnlyList<ReferenceItem> Items { get; }
+
+        // Reference: non-null when the chain ends with a quoted-literal or format-call default.
+        // The list always contains exactly one element (a Literal or a Format token), encoded
+        // as a list to share the resolution code path with templates. Null when the chain has
+        // no explicit default.
+        internal IReadOnlyList<ValueToken>? Default { get; }
+
+        // Reference: true when the chain ends with a bare '?' (empty-string fallback). Mutually
+        // exclusive with Default at parse time.
+        internal bool HasEmptyDefault { get; }
+
+        // Format: inner Literal / Reference tokens.
+        internal IReadOnlyList<ValueToken> Tokens { get; }
+
+        // True when this Reference token has any path member to try.
+        internal bool HasHead => Items.Count > 0;
+
+        internal bool HasDefault => Default is not null || HasEmptyDefault;
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceResolutionConfigurationBuilderExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceResolutionConfigurationBuilderExtensions.cs
new file mode 100644
index 00000000000000..157fa1a56890f4
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceResolutionConfigurationBuilderExtensions.cs
@@ -0,0 +1,194 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Extensions.Configuration
+{
+    /// <summary>
+    /// Provides extension methods for configuring how individual <see cref="IConfigurationSource"/>
+    /// instances participate in <c>ref(...)</c> / <c>format(...)</c> reference resolution
+    /// performed by the <see cref="IConfigurationRoot"/> built from the containing
+    /// <see cref="IConfigurationBuilder"/>.
+    /// </summary>
+    /// <remarks>
+    /// Sources default to <see cref="ReferenceMode.Read"/>: they are valid substitution targets
+    /// for other sources but their own values are not scanned for references. Mark at least one
+    /// source with <see cref="ReferenceMode.Scan"/> to activate the reference-resolution engine.
+    /// </remarks>
+    public static class ReferenceResolutionConfigurationBuilderExtensions
+    {
+        // Signal placed in IConfigurationBuilder.Properties that carries the per-source mode
+        // overrides. The value is a Dictionary<IConfigurationSource, ReferenceMode>
+        // (reference-equality keys); at Build time it is correlated with the produced providers
+        // so the engine can apply the correct mode per provider without wrapping them. Sources
+        // without an entry default to ReferenceMode.Read.
+        internal const string SourceModesPropertyName = "Microsoft.Extensions.Configuration.ReferenceResolution.SourceModes";
+
+        /// <summary>
+        /// Sets the <see cref="ReferenceMode"/> for the most recently added source on the
+        /// builder.
+        /// </summary>
+        /// <param name="configurationBuilder">The <see cref="IConfigurationBuilder"/> whose last source should be configured.</param>
+        /// <param name="mode">The mode to apply to the source.</param>
+        /// <returns>The same <see cref="IConfigurationBuilder"/>.</returns>
+        /// <exception cref="InvalidOperationException">The builder has no sources to configure.</exception>
+        public static IConfigurationBuilder SetReferenceMode(this IConfigurationBuilder configurationBuilder, ReferenceMode mode)
+        {
+            ArgumentNullException.ThrowIfNull(configurationBuilder);
+
+            IList<IConfigurationSource> sources = configurationBuilder.Sources;
+            if (sources.Count == 0)
+            {
+                throw new InvalidOperationException(SR.ReferenceResolution_NoSourceToConfigure);
+            }
+
+            SetSourceMode(configurationBuilder, sources[sources.Count - 1], mode);
+            return configurationBuilder;
+        }
+
+        /// <summary>
+        /// Sets the <see cref="ReferenceMode"/> for the specified source. Use this to configure
+        /// sources added by a host or other caller after they were registered.
+        /// </summary>
+        /// <param name="configurationBuilder">The <see cref="IConfigurationBuilder"/> containing the source.</param>
+        /// <param name="source">The source to configure. Must already be present in <see cref="IConfigurationBuilder.Sources"/>.</param>
+        /// <param name="mode">The mode to apply to the source.</param>
+        /// <returns>The same <see cref="IConfigurationBuilder"/>.</returns>
+        /// <exception cref="ArgumentException">The specified source is not present in the builder.</exception>
+        public static IConfigurationBuilder SetReferenceMode(this IConfigurationBuilder configurationBuilder, IConfigurationSource source, ReferenceMode mode)
+        {
+            ArgumentNullException.ThrowIfNull(configurationBuilder);
+            ArgumentNullException.ThrowIfNull(source);
+
+            if (!configurationBuilder.Sources.Contains(source))
+            {
+                throw new ArgumentException(SR.ReferenceResolution_SourceNotFound, nameof(source));
+            }
+
+            SetSourceMode(configurationBuilder, source, mode);
+            return configurationBuilder;
+        }
+
+        /// <summary>
+        /// Sets the <see cref="ReferenceMode"/> for a batch of sources. Each source must already
+        /// be present in <see cref="IConfigurationBuilder.Sources"/>; validation runs before any
+        /// change is applied, so the operation is atomic.
+        /// </summary>
+        /// <param name="configurationBuilder">The <see cref="IConfigurationBuilder"/> containing the sources.</param>
+        /// <param name="sources">The sources to configure. A <see langword="null"/> enumerable is treated as empty.</param>
+        /// <param name="mode">The mode to apply to every source in <paramref name="sources"/>.</param>
+        /// <returns>The same <see cref="IConfigurationBuilder"/>.</returns>
+        /// <exception cref="ArgumentException">A source in <paramref name="sources"/> is <see langword="null"/> or not present in the builder.</exception>
+        public static IConfigurationBuilder SetReferenceMode(this IConfigurationBuilder configurationBuilder, IEnumerable<IConfigurationSource> sources, ReferenceMode mode)
+        {
+            ArgumentNullException.ThrowIfNull(configurationBuilder);
+
+            if (sources is null)
+            {
+                return configurationBuilder;
+            }
+
+            // Materialize once and validate up-front so partial application is impossible.
+            var materialized = new List<IConfigurationSource>();
+            foreach (IConfigurationSource source in sources)
+            {
+                if (source is null)
+                {
+                    throw new ArgumentException(SR.ReferenceResolution_SourceNotFound, nameof(sources));
+                }
+                if (!configurationBuilder.Sources.Contains(source))
+                {
+                    throw new ArgumentException(SR.ReferenceResolution_SourceNotFound, nameof(sources));
+                }
+                materialized.Add(source);
+            }
+
+            foreach (IConfigurationSource source in materialized)
+            {
+                SetSourceMode(configurationBuilder, source, mode);
+            }
+
+            return configurationBuilder;
+        }
+
+        internal static Dictionary<IConfigurationSource, ReferenceMode>? TryGetSourceModes(IDictionary<string, object> properties)
+        {
+            if (properties is not null && properties.TryGetValue(SourceModesPropertyName, out object? raw))
+            {
+                return raw as Dictionary<IConfigurationSource, ReferenceMode>;
+            }
+
+            return null;
+        }
+
+        // Projects the per-source mode overrides onto the produced providers by positional
+        // correspondence. Sources and providers share order: ConfigurationBuilder.Build iterates
+        // sources to produce providers, and ConfigurationManager tracks source additions one-to-one
+        // with provider additions. Providers whose source has no override are omitted — callers
+        // treat a missing key as ReferenceMode.Scan. Mismatched counts return null.
+        internal static Dictionary<IConfigurationProvider, ReferenceMode>? ResolveProviderModes(
+            IDictionary<string, object> properties,
+            IList<IConfigurationSource> sources,
+            IReadOnlyList<IConfigurationProvider> providers)
+        {
+            Dictionary<IConfigurationSource, ReferenceMode>? overrides = TryGetSourceModes(properties);
+            if (overrides is null || overrides.Count == 0 || sources.Count != providers.Count)
+            {
+                return null;
+            }
+
+            Dictionary<IConfigurationProvider, ReferenceMode>? result = null;
+            for (int i = 0; i < sources.Count; i++)
+            {
+                if (overrides.TryGetValue(sources[i], out ReferenceMode mode))
+                {
+                    result ??= new Dictionary<IConfigurationProvider, ReferenceMode>();
+                    result[providers[i]] = mode;
+                }
+            }
+
+            return result;
+        }
+
+        // Checks whether at least one source is explicitly Scan. Sources without an override
+        // default to Read, which only makes them substitution targets for Scan sources — so
+        // the engine has no work unless at least one source opts into Scan. Used by the
+        // builder/manager to decide whether to attach the engine at Build time.
+        internal static bool HasAnyScanSource(IDictionary<string, object> properties, IList<IConfigurationSource> sources)
+        {
+            if (sources.Count == 0)
+            {
+                return false;
+            }
+
+            Dictionary<IConfigurationSource, ReferenceMode>? overrides = TryGetSourceModes(properties);
+            if (overrides is null || overrides.Count == 0)
+            {
+                return false;
+            }
+
+            foreach (ReferenceMode mode in overrides.Values)
+            {
+                if (mode == ReferenceMode.Scan)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static void SetSourceMode(IConfigurationBuilder configurationBuilder, IConfigurationSource source, ReferenceMode mode)
+        {
+            // Dictionary is written back to Properties whether newly created or not so that
+            // builders whose Properties dictionary reacts to writes (e.g., ConfigurationManager)
+            // trigger a rebuild of the engine with the new mode map.
+            Dictionary<IConfigurationSource, ReferenceMode> map = TryGetSourceModes(configurationBuilder.Properties)
+                ?? new Dictionary<IConfigurationSource, ReferenceMode>();
+            map[source] = mode;
+            configurationBuilder.Properties[SourceModesPropertyName] = map;
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceResolutionEngine.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceResolutionEngine.cs
new file mode 100644
index 00000000000000..c723b6e4d8454f
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/ReferenceResolutionEngine.cs
@@ -0,0 +1,881 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.Extensions.Configuration
+{
+    // Root-owned resolution engine. Backs IConfigurationRoot.this[key] and GetChildren when a
+    // builder has marked at least one source with ReferenceMode.Scan. Holds the ordered provider
+    // set and the resolution cache; subscribes to the composite reload token so the cache is
+    // dropped whenever any inner provider reloads.
+    //
+    // Per-source modes (ReferenceMode): each provider carries a mode derived from its source's
+    // configuration. Default is Read. Providers with mode Ignore are invisible to the engine as
+    // substitution targets (GetRawValue skips them). Providers whose mode is not Scan are not
+    // parsed for {{…}} — their values are returned sealed, so the engine returns
+    // them as literals. At least one provider must be in Scan mode for the engine to be attached
+    // at Build time.
+    internal sealed class ReferenceResolutionEngine : IDisposable
+    {
+        private const int MaxDepth = 1024;
+        private const int CycleCheckThreshold = 32;
+
+        private readonly ProviderSet _providers;
+        private readonly AliasFinder _aliasFinder;
+        private readonly ReferenceResolver _resolver;
+        private readonly IDisposable[] _changeTokenRegistrations;
+
+        private volatile ConcurrentDictionary<string, string?> _cache = new(StringComparer.OrdinalIgnoreCase);
+
+        internal ReferenceResolutionEngine(
+            IReadOnlyList<IConfigurationProvider> providers,
+            IReadOnlyDictionary<IConfigurationProvider, ReferenceMode>? providerModes = null)
+        {
+            ArgumentNullException.ThrowIfNull(providers);
+
+            _providers = new ProviderSet(providers, providerModes);
+            _aliasFinder = new AliasFinder(_providers);
+            _resolver = new ReferenceResolver(_providers, _aliasFinder);
+
+            // Subscribe to each provider's reload token individually. Using a CompositeChangeToken
+            // here would leak child subscriptions: CompositeChangeToken only cleans up its inner
+            // registrations when it fires, not when the outer registration is disposed.
+            _changeTokenRegistrations = new IDisposable[providers.Count];
+            for (int i = 0; i < providers.Count; i++)
+            {
+                IConfigurationProvider provider = providers[i];
+                _changeTokenRegistrations[i] = ChangeToken.OnChange(provider.GetReloadToken, Invalidate);
+            }
+        }
+
+        public bool TryGet(string key, out string? value)
+        {
+            ConcurrentDictionary<string, string?> cache = _cache;
+            var path = new Path(key);
+
+            if (cache.TryGetValue(path.Value, out value))
+            {
+                return true;
+            }
+
+            bool hasTopLayer = _providers.TryGetTopLayer(path, out string? topValue, out int topIndex, out ReferenceMode topMode);
+
+            // Literal short-circuit: the top provider is not scanned. Return its value as-is and
+            // skip alias discovery. Covers Ignore / Read uniformly — sources outside the scan set
+            // don't participate as alias targets in either direction.
+            if (hasTopLayer && topMode != ReferenceMode.Scan)
+            {
+                value = topValue;
+                cache.TryAdd(path.Value, value);
+                return true;
+            }
+
+            Value raw = hasTopLayer
+                ? (topValue is null ? Value.Section(topIndex) : Value.Leaf(topValue, topIndex))
+                : Value.Missing;
+
+            // An ancestor section alias defined at a later provider shadows this key;
+            // rebase the key into the aliased target and read from there. If the alias target
+            // is empty (no value and no children), fall through to raw handling so a value from
+            // an earlier provider below the alias still surfaces.
+            if (_aliasFinder.TryFindAncestor(path, out SectionAlias alias) &&
+                (!raw.Exists || alias.SourceIndex > raw.ProviderIndex))
+            {
+                Path targetKey = alias.Rebase(path);
+                Value target = _providers.GetRawValue(targetKey, alias.SourceIndex);
+
+                if (target.Exists)
+                {
+                    if (target.NeedsResolving)
+                    {
+                        _resolver.TryResolve(targetKey, target.AsString!, target.ProviderIndex, out value);
+                    }
+                    else
+                    {
+                        value = target.AsString;
+                    }
+
+                    cache.TryAdd(path.Value, value);
+                    return true;
+                }
+
+                if (_providers.GetDirectChildKeys(targetKey, alias.SourceIndex)?.Any() is true)
+                {
+                    value = null;
+                    cache.TryAdd(path.Value, value);
+                    return true;
+                }
+
+                // Alias target is empty. For a strict alias, do not fall through: earlier providers'
+                // values under the aliased path are hidden by construction. Return no value.
+                if (alias.Strict)
+                {
+                    value = null;
+                    cache.TryAdd(path.Value, value);
+                    return false;
+                }
+
+                // Non-strict: fall through; earlier providers' raw value (if any) wins.
+            }
+
+            if (!raw.Exists)
+            {
+                value = null;
+                return false;
+            }
+
+            if (!raw.NeedsResolving)
+            {
+                value = raw.AsString;
+                return true;
+            }
+
+            // A single-token section alias at this exact key surfaces as a section (null leaf).
+            if (_aliasFinder.IsDirectSectionAlias(path, raw, out _))
+            {
+                value = null;
+                cache.TryAdd(path.Value, value);
+                return true;
+            }
+
+            _resolver.TryResolve(path, raw.AsString!, _providers.LastIndex, out value);
+
+            cache.TryAdd(path.Value, value);
+            return true;
+        }
+
+        public IEnumerable<string> GetChildKeys(IEnumerable<string> earlierKeys, string? parentPath)
+        {
+            ArgumentNullException.ThrowIfNull(earlierKeys);
+
+            if (string.IsNullOrEmpty(parentPath) || _providers.IsEmpty)
+            {
+                return earlierKeys;
+            }
+
+            var parent = new Path(parentPath);
+            Value raw = _providers.GetRawValue(parent);
+            SectionAlias alias = SectionAlias.None;
+
+            if (raw.NeedsResolving)
+            {
+                _aliasFinder.IsDirectSectionAlias(parent, raw, out alias);
+            }
+
+            if (alias.IsEmpty && !_aliasFinder.TryFindAncestor(parent, out alias))
+            {
+                return earlierKeys;
+            }
+
+            Path targetParent = alias.Rebase(parent);
+            IEnumerable<string>? aliasedChildren = _providers.GetDirectChildKeys(targetParent, alias.SourceIndex);
+            if (aliasedChildren is null)
+            {
+                return earlierKeys;
+            }
+
+            // Dedupe while preserving first occurrence order, then sort via ConfigurationKeyComparer.
+            var merged = new List<string>();
+            merged.AddRange(aliasedChildren);
+            // For a strict alias, the aliased target is the sole source under this section.
+            // Discard earlierKeys (which may include contributions from providers at or below the
+            // alias) and re-merge only the children contributed by providers strictly above the
+            // alias — those later providers shadow the alias and must still participate.
+            if (alias.Strict)
+            {
+                IEnumerable<string>? postAliasChildren = _providers.GetDirectChildKeysAbove(parent, alias.SourceIndex);
+                if (postAliasChildren is not null)
+                {
+                    merged.AddRange(postAliasChildren);
+                }
+            }
+            else
+            {
+                merged.AddRange(earlierKeys);
+            }
+
+            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            var result = new List<string>(merged.Count);
+            foreach (string s in merged)
+            {
+                if (seen.Add(s))
+                {
+                    result.Add(s);
+                }
+            }
+
+            result.Sort(ConfigurationKeyComparer.Comparison);
+            return result;
+        }
+
+        public void Dispose()
+        {
+            foreach (IDisposable registration in _changeTokenRegistrations)
+            {
+                registration.Dispose();
+            }
+        }
+
+        public void Invalidate()
+        {
+            _cache = new ConcurrentDictionary<string, string?>(StringComparer.OrdinalIgnoreCase);
+        }
+
+        private readonly struct ProviderSet
+        {
+            private readonly IConfigurationProvider[] _providers;
+            private readonly ReferenceMode[] _modes;
+
+            public ProviderSet(
+                IReadOnlyList<IConfigurationProvider> providers,
+                IReadOnlyDictionary<IConfigurationProvider, ReferenceMode>? providerModes)
+            {
+                _providers = [.. providers];
+                _modes = new ReferenceMode[_providers.Length];
+                for (int i = 0; i < _providers.Length; i++)
+                {
+                    _modes[i] = providerModes is not null && providerModes.TryGetValue(_providers[i], out ReferenceMode mode)
+                        ? mode
+                        : ReferenceMode.Read;
+                }
+            }
+
+            public bool IsEmpty => _providers.Length == 0;
+
+            public int LastIndex => _providers.Length - 1;
+
+            private bool IsReadable(int index) => _modes[index] != ReferenceMode.Ignore;
+
+            private bool IsScanned(int index) => _modes[index] == ReferenceMode.Scan;
+
+            // Walks providers from upperIndex down to 0 and returns the first hit, SKIPPING
+            // providers whose mode lacks the Read flag. Used by substitution and alias scans
+            // so that values from non-readable sources never leak into resolved output.
+            // Values from providers without the Scan flag are returned sealed so the engine
+            // treats their {{…}} text as literal.
+            public Value GetRawValue(Path key, int? upperIndex = null)
+            {
+                for (int i = upperIndex ?? LastIndex; i >= 0; i--)
+                {
+                    if (!IsReadable(i))
+                    {
+                        continue;
+                    }
+
+                    if (_providers[i].TryGet(key.Value, out string? value))
+                    {
+                        return value is null
+                            ? Value.Section(i)
+                            : Value.Leaf(value, i, isSealed: !IsScanned(i));
+                    }
+                }
+
+                return Value.Missing;
+            }
+
+            // Walks ALL providers top-down (regardless of mode) to find which provider owns the
+            // top-most hit at the engine's entry point. Returns true with the hit's value, index,
+            // and mode, false when no provider has the key.
+            public bool TryGetTopLayer(Path key, out string? value, out int providerIndex, out ReferenceMode mode)
+            {
+                for (int i = LastIndex; i >= 0; i--)
+                {
+                    if (_providers[i].TryGet(key.Value, out string? v))
+                    {
+                        value = v;
+                        providerIndex = i;
+                        mode = _modes[i];
+                        return true;
+                    }
+                }
+
+                value = null;
+                providerIndex = -1;
+                mode = ReferenceMode.Ignore;
+                return false;
+            }
+
+            // Merges GetChildKeys across readable providers [0..upperIndex] in ascending order.
+            // Non-readable providers are skipped to keep the engine's merged child view consistent
+            // with GetRawValue's skipping behavior.
+            public IEnumerable<string>? GetDirectChildKeys(Path parentPath, int upperIndex)
+            {
+                if (upperIndex < 0)
+                {
+                    return null;
+                }
+
+                IEnumerable<string> childKeys = Array.Empty<string>();
+                for (int i = 0; i <= upperIndex; i++)
+                {
+                    if (!IsReadable(i))
+                    {
+                        continue;
+                    }
+
+                    childKeys = _providers[i].GetChildKeys(childKeys, parentPath.Value);
+                }
+
+                return childKeys;
+            }
+
+            // Merges GetChildKeys across readable providers (lowerIndexExclusive..LastIndex].
+            // Used by strict section aliases to admit only children contributed by providers
+            // strictly above the alias declaration.
+            public IEnumerable<string>? GetDirectChildKeysAbove(Path parentPath, int lowerIndexExclusive)
+            {
+                int lastIndex = LastIndex;
+                if (lowerIndexExclusive >= lastIndex)
+                {
+                    return null;
+                }
+
+                IEnumerable<string> childKeys = Array.Empty<string>();
+                for (int i = lowerIndexExclusive + 1; i <= lastIndex; i++)
+                {
+                    if (!IsReadable(i))
+                    {
+                        continue;
+                    }
+
+                    childKeys = _providers[i].GetChildKeys(childKeys, parentPath.Value);
+                }
+
+                return childKeys;
+            }
+
+            // A path is a "section" if it has no direct value but does have children.
+            public bool IsSectionPath(Path path, int upperIndex)
+            {
+                Value raw = GetRawValue(path, upperIndex);
+                if (raw.Exists)
+                {
+                    return raw.IsSection;
+                }
+
+                return GetDirectChildKeys(path, upperIndex)?.Any() is true;
+            }
+        }
+
+        private readonly struct AliasFinder
+        {
+            private readonly ProviderSet _providers;
+
+            public AliasFinder(ProviderSet providers)
+            {
+                _providers = providers;
+            }
+
+            // Detects whether `raw` at `path` is a top-level ref(...) call whose chain resolves
+            // to a section (e.g. ref(Other:Section)). Sections are always strict — earlier-
+            // provider keys are not merged under the alias path.
+            public bool IsDirectSectionAlias(Path path, Value raw, out SectionAlias alias)
+            {
+                if (!raw.IsLeaf)
+                {
+                    alias = SectionAlias.None;
+                    return false;
+                }
+
+                ValueToken token = ReferenceParser.Parse(raw.AsString!);
+
+                if (token.Kind == ValueTokenKind.Reference &&
+                    token.HasHead &&
+                    TryDetectSectionTarget(token, raw.ProviderIndex, out Path targetPath))
+                {
+                    alias = new SectionAlias(path, targetPath, raw.ProviderIndex, strict: true);
+                    return true;
+                }
+
+                alias = SectionAlias.None;
+                return false;
+            }
+
+            // Walks ancestors of `key` looking for a section alias that rebases the key.
+            public bool TryFindAncestor(Path key, out SectionAlias alias)
+            {
+                int lastIndex = _providers.LastIndex;
+
+                Path current = key;
+                while (current.TryGetParent(out Path ancestor))
+                {
+                    Value raw = _providers.GetRawValue(ancestor, lastIndex);
+                    if (raw.NeedsResolving && IsDirectSectionAlias(ancestor, raw, out alias))
+                    {
+                        return true;
+                    }
+
+                    current = ancestor;
+                }
+
+                alias = SectionAlias.None;
+                return false;
+            }
+
+            // A token targets a section if any reference item in its chain resolves to a section
+            // (order preserved; the first matching reference wins).
+            private bool TryDetectSectionTarget(ValueToken token, int sourceProviderIndex, out Path targetPath)
+            {
+                foreach (ReferenceItem item in token.Items)
+                {
+                    var candidate = Path.FromReference(item.Value);
+                    if (!candidate.IsEmpty && _providers.IsSectionPath(candidate, sourceProviderIndex))
+                    {
+                        targetPath = candidate;
+                        return true;
+                    }
+                }
+
+                targetPath = default;
+                return false;
+            }
+
+            // Shadowing lookup via ancestor section alias. Returns true with the aliased `result` and the
+            // `effectivePath` where it physically lives when:
+            //   - an ancestor of `key` is a section alias visible within `upperIndex`, AND
+            //   - either `raw` is missing or the alias was declared at a later provider (shadowing rule), AND
+            //   - the rebased target has a direct value or children.
+            // Returns false when no alias applies or the alias target is absent (caller uses `raw`).
+            public bool TryResolveViaAncestor(Path key, int upperIndex, Value raw, out Value result, out Path effectivePath)
+            {
+                if (TryFindAncestor(key, out SectionAlias alias) &&
+                    alias.SourceIndex <= upperIndex &&
+                    (!raw.Exists || alias.SourceIndex > raw.ProviderIndex))
+                {
+                    effectivePath = alias.Rebase(key);
+                    Value target = _providers.GetRawValue(effectivePath, alias.SourceIndex);
+                    if (target.Exists)
+                    {
+                        result = target;
+                        return true;
+                    }
+
+                    if (_providers.GetDirectChildKeys(effectivePath, alias.SourceIndex)?.Any() is true)
+                    {
+                        result = Value.Section(alias.SourceIndex);
+                        return true;
+                    }
+                }
+
+                result = default;
+                effectivePath = default;
+                return false;
+            }
+        }
+
+        private readonly struct ReferenceResolver
+        {
+            private readonly ProviderSet _providers;
+            private readonly AliasFinder _aliasFinder;
+
+            public ReferenceResolver(ProviderSet providers, AliasFinder aliasFinder)
+            {
+                _providers = providers;
+                _aliasFinder = aliasFinder;
+            }
+
+            public bool TryResolve(Path originKey, string rawValue, int upperIndex, out string? value)
+                => TryResolveValue(originKey, rawValue, resolutionStack: null, depth: 0, upperIndex, out value);
+
+            private bool TryResolveValue(Path originKey, string rawValue, HashSet<Path>? resolutionStack, int depth, int upperIndex, out string? value)
+            {
+                if (depth > MaxDepth)
+                {
+                    throw new InvalidOperationException(SR.Format(SR.ReferenceResolution_MaxDepthExceeded, MaxDepth, originKey));
+                }
+
+                // Only start paying for cycle tracking once recursion is deep enough to suggest a loop.
+                if (depth >= CycleCheckThreshold && resolutionStack is null)
+                {
+                    resolutionStack = new HashSet<Path>();
+                }
+
+                if (resolutionStack is not null && !resolutionStack.Add(originKey))
+                {
+                    throw new InvalidOperationException(SR.Format(SR.ReferenceResolution_CircularReference, originKey));
+                }
+
+                try
+                {
+                    ValueToken token = ReferenceParser.Parse(rawValue);
+                    return TryResolveTopToken(originKey, token, resolutionStack, depth, upperIndex, out value);
+                }
+                finally
+                {
+                    resolutionStack?.Remove(originKey);
+                }
+            }
+
+            // Top-level token resolution: a single Literal, Reference (may surface a section as a
+            // null leaf), or Format (always a concatenated string with embedded refs that must
+            // resolve to scalars).
+            private bool TryResolveTopToken(Path originKey, ValueToken token, HashSet<Path>? resolutionStack, int depth, int upperIndex, out string? value)
+            {
+                switch (token.Kind)
+                {
+                    case ValueTokenKind.Literal:
+                        value = token.Value;
+                        return true;
+
+                    case ValueTokenKind.Reference:
+                        return TryResolveReference(originKey, token, resolutionStack, depth + 1, upperIndex, allowSection: true, out value);
+
+                    case ValueTokenKind.Format:
+                        return TryResolveFormat(originKey, token.Tokens, resolutionStack, depth + 1, upperIndex, out value);
+
+                    default:
+                        value = null;
+                        return false;
+                }
+            }
+
+            // Resolve a Format body (sequence of Literal and Reference tokens) by concatenating
+            // the resolved string for each token. Embedded ref(...) calls inside a format body
+            // MUST resolve to a scalar value; section results throw.
+            private bool TryResolveFormat(Path originKey, IReadOnlyList<ValueToken> tokens, HashSet<Path>? resolutionStack, int depth, int upperIndex, out string? value)
+            {
+                var builder = new StringBuilder();
+                foreach (ValueToken token in tokens)
+                {
+                    if (token.Kind == ValueTokenKind.Literal)
+                    {
+                        builder.Append(token.Value);
+                        continue;
+                    }
+
+                    if (token.Kind == ValueTokenKind.Format)
+                    {
+                        if (!TryResolveFormat(originKey, token.Tokens, resolutionStack, depth, upperIndex, out string? nestedValue))
+                        {
+                            value = null;
+                            return false;
+                        }
+
+                        builder.Append(nestedValue ?? string.Empty);
+                        continue;
+                    }
+
+                    if (!TryResolveReference(originKey, token, resolutionStack, depth, upperIndex, allowSection: false, out string? resolvedTokenValue))
+                    {
+                        value = null;
+                        return false;
+                    }
+
+                    builder.Append(resolvedTokenValue ?? string.Empty);
+                }
+
+                value = builder.ToString();
+                return true;
+            }
+
+            // Resolve a Reference token's coalesce chain. When `allowSection` is true, a path that
+            // resolves to a section produces a null leaf result. When `allowSection` is false (i.e.
+            // the reference appears inside a format(...) template), a section result throws.
+            private bool TryResolveReference(Path storageKey, ValueToken token, HashSet<Path>? resolutionStack, int depth, int upperIndex, bool allowSection, out string? value)
+            {
+                foreach (ReferenceItem item in token.Items)
+                {
+                    if (!TryBuildAbsolutePath(storageKey, item, out Path tokenPath))
+                    {
+                        continue;
+                    }
+
+                    Value raw = _providers.GetRawValue(tokenPath, upperIndex);
+
+                    // Honor ancestor section aliases so tokens inside a value see the same key space as
+                    // direct reads. Matches TryGet's shadowing rules: an alias at a later provider wins
+                    // over a raw value at an earlier one; a missing alias target falls back to `raw`.
+                    if (_aliasFinder.TryResolveViaAncestor(tokenPath, upperIndex, raw, out Value aliased, out _))
+                    {
+                        raw = aliased;
+                    }
+
+                    if (!raw.Exists)
+                    {
+                        // The path may still represent a section (has children but no direct value).
+                        if (_providers.IsSectionPath(tokenPath, upperIndex))
+                        {
+                            if (!allowSection)
+                            {
+                                throw new InvalidOperationException(
+                                    SR.Format(SR.ReferenceResolution_SectionInFormat, tokenPath, storageKey));
+                            }
+
+                            value = null;
+                            return true;
+                        }
+
+                        continue;
+                    }
+
+                    if (raw.IsSection)
+                    {
+                        if (!allowSection)
+                        {
+                            throw new InvalidOperationException(
+                                SR.Format(SR.ReferenceResolution_SectionInFormat, tokenPath, storageKey));
+                        }
+
+                        value = null;
+                        return true;
+                    }
+
+                    if (raw.NeedsResolving)
+                    {
+                        // Recurse with the same allowSection flag so a leaf whose value is a single
+                        // ref(...) preserves section semantics for top-level reads but throws when
+                        // it surfaces inside a format(...).
+                        if (allowSection)
+                        {
+                            return TryResolveValue(tokenPath, raw.AsString!, resolutionStack, depth, raw.ProviderIndex, out value);
+                        }
+
+                        return TryResolveValueAsString(tokenPath, raw.AsString!, resolutionStack, depth, raw.ProviderIndex, out value);
+                    }
+
+                    value = raw.AsString;
+                    return true;
+                }
+
+                // No path resolved. Apply the chain default.
+                if (token.HasEmptyDefault)
+                {
+                    value = string.Empty;
+                    return true;
+                }
+
+                if (token.Default is { } defaultTokens)
+                {
+                    // The default member is either a single Literal token or a single Format token
+                    // (encoded as a one-element list). Resolve as a format-style concatenation; in
+                    // either case the result is a scalar string and sections in inner refs throw.
+                    return TryResolveFormat(storageKey, defaultTokens, resolutionStack, depth, upperIndex, out value);
+                }
+
+                string missing = string.Join("?", token.Items.Select(i => i.Value));
+                throw new KeyNotFoundException(
+                    SR.Format(SR.ReferenceResolution_KeyNotFound, missing, storageKey));
+            }
+
+            // Variant of TryResolveValue used when recursing from inside a format(...) context.
+            // Re-parses the leaf value and refuses any section result.
+            private bool TryResolveValueAsString(Path originKey, string rawValue, HashSet<Path>? resolutionStack, int depth, int upperIndex, out string? value)
+            {
+                if (depth > MaxDepth)
+                {
+                    throw new InvalidOperationException(SR.Format(SR.ReferenceResolution_MaxDepthExceeded, MaxDepth, originKey));
+                }
+
+                if (depth >= CycleCheckThreshold && resolutionStack is null)
+                {
+                    resolutionStack = new HashSet<Path>();
+                }
+
+                if (resolutionStack is not null && !resolutionStack.Add(originKey))
+                {
+                    throw new InvalidOperationException(SR.Format(SR.ReferenceResolution_CircularReference, originKey));
+                }
+
+                try
+                {
+                    ValueToken token = ReferenceParser.Parse(rawValue);
+                    switch (token.Kind)
+                    {
+                        case ValueTokenKind.Literal:
+                            value = token.Value;
+                            return true;
+                        case ValueTokenKind.Reference:
+                            return TryResolveReference(originKey, token, resolutionStack, depth + 1, upperIndex, allowSection: false, out value);
+                        case ValueTokenKind.Format:
+                            return TryResolveFormat(originKey, token.Tokens, resolutionStack, depth + 1, upperIndex, out value);
+                        default:
+                            value = null;
+                            return false;
+                    }
+                }
+                finally
+                {
+                    resolutionStack?.Remove(originKey);
+                }
+            }
+
+            private static bool TryBuildAbsolutePath(Path storageKey, ReferenceItem item, out Path absolute)
+            {
+                if (item.ParentHops == 0)
+                {
+                    absolute = Path.FromReference(item.Value);
+                    return true;
+                }
+
+                if (!storageKey.TryGetAncestor(item.ParentHops, out Path anchor))
+                {
+                    absolute = Path.Empty;
+                    return false;
+                }
+
+                absolute = item.Value.Length == 0 ? anchor : anchor.Combine(Path.FromReference(item.Value).Value);
+                return true;
+            }
+        }
+
+        private readonly struct Path : IComparable<Path>, IEquatable<Path>
+        {
+            public static Path Empty => default;
+
+            public string Value { get; }
+
+            public int Length => Value?.Length ?? 0;
+
+            public bool IsEmpty => string.IsNullOrEmpty(Value);
+
+            public static Path FromReference(string value)
+            {
+                return new Path(value.Trim().Replace('.', ConfigurationPath.KeyDelimiter[0]));
+            }
+
+            public Path(string value)
+            {
+                Value = value;
+            }
+
+            public bool IsParentOf(Path candidate)
+            {
+                return candidate.Length > Length &&
+                    candidate.Value.StartsWith(Value, StringComparison.OrdinalIgnoreCase) &&
+                    candidate.Value[Length] == ConfigurationPath.KeyDelimiter[0];
+            }
+
+            public bool IsEqualTo(Path candidate) => Equals(candidate);
+
+            public bool IsChildOf(Path candidate) => candidate.IsParentOf(this);
+
+            public Path Combine(string child)
+            {
+                if (IsEmpty)
+                {
+                    return new Path(child);
+                }
+
+                return new Path(Value + ConfigurationPath.KeyDelimiter + child);
+            }
+
+            public bool TryGetParent(out Path parent)
+            {
+                int idx = Value?.LastIndexOf(ConfigurationPath.KeyDelimiter[0]) ?? -1;
+                if (idx < 0)
+                {
+                    parent = Empty;
+                    return false;
+                }
+
+                parent = new Path(Value!.Substring(0, idx));
+                return true;
+            }
+
+            public bool TryGetAncestor(int hops, out Path ancestor)
+            {
+                ancestor = this;
+                for (int n = 0; n < hops; n++)
+                {
+                    if (!ancestor.TryGetParent(out Path next))
+                    {
+                        ancestor = Empty;
+                        return false;
+                    }
+
+                    ancestor = next;
+                }
+
+                return true;
+            }
+
+            public Path Rebase(Path fromRoot, Path toRoot)
+            {
+                if (Length == fromRoot.Length)
+                {
+                    return toRoot;
+                }
+
+                return new Path(toRoot.Value + Value.Substring(fromRoot.Length));
+            }
+
+            public bool Equals(Path other) => string.Equals(Value, other.Value, StringComparison.OrdinalIgnoreCase);
+
+            public override bool Equals(object? obj) => obj is Path other && Equals(other);
+
+            public override int GetHashCode() => Value is null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(Value);
+
+            public override string ToString() => Value ?? string.Empty;
+
+            public int CompareTo(Path other) => ConfigurationKeyComparer.Instance.Compare(Value, other.Value);
+        }
+
+        private readonly struct SectionAlias
+        {
+            public static SectionAlias None => new(default, default, -1, strict: false);
+
+            public Path Source { get; }
+
+            public Path Target { get; }
+
+            public int SourceIndex { get; }
+
+            public bool Strict { get; }
+
+            public SectionAlias(Path source, Path target, int sourceIndex, bool strict)
+            {
+                Source = source;
+                Target = target;
+                SourceIndex = sourceIndex;
+                Strict = strict;
+            }
+
+            public bool IsEmpty => SourceIndex < 0;
+
+            public Path Rebase(Path key) => key.Rebase(Source, Target);
+        }
+
+        private readonly struct Value
+        {
+            public static Value Missing => default;
+
+            public static Value Section(int providerIndex) => new(null, providerIndex, isLeaf: false, exists: true, isSealed: false);
+
+            public static Value Leaf(string? value, int providerIndex, bool isSealed = false) => new(value, providerIndex, isLeaf: true, exists: true, isSealed: isSealed);
+
+            private Value(string? value, int providerIndex, bool isLeaf, bool exists, bool isSealed)
+            {
+                AsString = value;
+                ProviderIndex = providerIndex;
+                IsLeaf = isLeaf;
+                Exists = exists;
+                IsSealed = isSealed;
+            }
+
+            public string? AsString { get; }
+
+            public int ProviderIndex { get; }
+
+            public bool Exists { get; }
+
+            public bool IsLeaf { get; }
+
+            // True when the value came from another ReferenceResolutionConfigurationProvider and is
+            // already fully resolved. Later reference-resolution providers treat it as a literal and do
+            // not rescan it for tokens.
+            public bool IsSealed { get; }
+
+            public bool IsSection => Exists && !IsLeaf;
+
+            public bool NeedsResolving =>
+                IsLeaf && !IsSealed && AsString is not null && ReferenceParser.ContainsReference(AsString);
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/Resources/Strings.resx b/src/libraries/Microsoft.Extensions.Configuration/src/Resources/Strings.resx
index 4a1f5628be6829..ac2fdf2eb29adc 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/src/Resources/Strings.resx
+++ b/src/libraries/Microsoft.Extensions.Configuration/src/Resources/Strings.resx
@@ -129,4 +129,52 @@
   <data name="StreamConfigurationSourceStreamCannotBeNull" xml:space="preserve">
     <value>Source.Stream cannot be null.</value>
   </data>
-</root>
\ No newline at end of file
+  <data name="ReferenceResolution_CircularReference" xml:space="preserve">
+    <value>A circular reference was detected while resolving '{0}'.</value>
+  </data>
+  <data name="ReferenceResolution_ExpressionIsEmpty" xml:space="preserve">
+    <value>A reference expression at position '{0}' is empty.</value>
+  </data>
+  <data name="ReferenceResolution_ExpressionIsUnclosed" xml:space="preserve">
+    <value>An unclosed reference expression was found at position '{0}'.</value>
+  </data>
+  <data name="ReferenceResolution_TrailingContentAfterClose" xml:space="preserve">
+    <value>Unexpected content at position '{0}' after the closing ')' of a reference expression.</value>
+  </data>
+  <data name="ReferenceResolution_InvalidExpression" xml:space="preserve">
+    <value>A reference expression at position '{0}' is malformed.</value>
+  </data>
+  <data name="ReferenceResolution_KeyIsEmpty" xml:space="preserve">
+    <value>A reference expression at position '{0}' has an empty key.</value>
+  </data>
+  <data name="ReferenceResolution_KeyNotFound" xml:space="preserve">
+    <value>The reference key '{0}' referenced by '{1}' was not found. Add a fallback reference, a quoted literal default, or a trailing '?' for empty on miss (for example 'ref(Key?''default'')' or 'ref(Key?)').</value>
+  </data>
+  <data name="ReferenceResolution_MaxDepthExceeded" xml:space="preserve">
+    <value>Maximum reference-resolution depth '{0}' was exceeded while resolving '{1}'.</value>
+  </data>
+  <data name="ReferenceResolution_SectionReferenceMustBeSingleToken" xml:space="preserve">
+    <value>Section reference at '{0}' must be a single reference expression in the form 'ref(Path)'.</value>
+  </data>
+  <data name="ReferenceResolution_RedundantTrailingQuestion" xml:space="preserve">
+    <value>A reference expression at position '{0}' has both a literal/format default and a trailing '?'. Use one or the other.</value>
+  </data>
+  <data name="ReferenceResolution_DefaultMustBeLast" xml:space="preserve">
+    <value>A reference expression at position '{0}' has a path member after a literal or format default. Literal and format defaults must be the last member of the chain.</value>
+  </data>
+  <data name="ReferenceResolution_UnterminatedQuote" xml:space="preserve">
+    <value>A quoted member starting at position '{0}' is not terminated. Use a matching '\'' or '"' (doubled inside to escape).</value>
+  </data>
+  <data name="ReferenceResolution_TrailingContentAfterQuotedDefault" xml:space="preserve">
+    <value>Unexpected content at position '{0}' after a quoted body. The closing quote must be followed only by the surrounding ')' (optionally preceded by whitespace).</value>
+  </data>
+  <data name="ReferenceResolution_SectionInFormat" xml:space="preserve">
+    <value>The reference '{0}' inside a format(...) template at '{1}' resolves to a section. Sections are only allowed as a top-level ref(...) value.</value>
+  </data>
+  <data name="ReferenceResolution_NoSourceToConfigure" xml:space="preserve">
+    <value>The configuration builder has no sources; there is nothing to configure for reference resolution.</value>
+  </data>
+  <data name="ReferenceResolution_SourceNotFound" xml:space="preserve">
+    <value>The specified configuration source is not present in the builder.</value>
+  </data>
+</root>
diff --git a/src/libraries/Microsoft.Extensions.Configuration/tests/ConfigurationManagerTest.cs b/src/libraries/Microsoft.Extensions.Configuration/tests/ConfigurationManagerTest.cs
index e84f51b2c457fb..5ca2db13bd83e3 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/tests/ConfigurationManagerTest.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration/tests/ConfigurationManagerTest.cs
@@ -96,6 +96,147 @@ public void SettingIConfigurationBuilderPropertiesReloadsSources()
             Assert.False(reloadToken2.HasChanged);
         }
 
+        [Fact]
+        public void EnableReferenceResolutionResolvesValues()
+        {
+            var config = new ConfigurationManager();
+            IConfigurationBuilder builder = config;
+
+            builder.AddInMemoryCollection(new Dictionary<string, string>
+            {
+                ["Host"] = "api.example.com",
+                ["ServiceUrl"] = "format(https://{Host})",
+            });
+
+            builder.EnableReferenceResolution();
+
+            Assert.Equal("https://api.example.com", config["ServiceUrl"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionDoesNotReloadExistingSources()
+        {
+            var config = new ConfigurationManager();
+            IConfigurationBuilder builder = config;
+
+            var counter = new LoadCountingProvider(new Dictionary<string, string>
+            {
+                ["Host"] = "api.example.com",
+                ["ServiceUrl"] = "format(https://{Host})",
+            });
+
+            builder.Add(new LoadCountingSource(counter));
+            Assert.Equal(1, counter.LoadCount);
+
+            builder.EnableReferenceResolution();
+            Assert.Equal(1, counter.LoadCount);
+
+            builder.ConfigureReferenceResolution(ReferenceMode.Read);
+            Assert.Equal(1, counter.LoadCount);
+
+            // And the engine picked up the mode change for the existing provider.
+            Assert.Equal("format(https://{Host})", config["ServiceUrl"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionObservesLaterAddedSources()
+        {
+            var config = new ConfigurationManager();
+            IConfigurationBuilder builder = config;
+
+            builder.AddInMemoryCollection(new Dictionary<string, string>
+            {
+                ["ServiceUrl"] = "format(https://{Host??}fallback)",
+            });
+            builder.EnableReferenceResolution();
+
+            // Sources added after EnableReferenceResolution do participate in resolution;
+            // the engine is rebuilt whenever the source list changes.
+            builder.AddInMemoryCollection(new Dictionary<string, string>
+            {
+                ["Host"] = "api.example.com",
+            });
+
+            Assert.Equal("https://api.example.comfallback", config["ServiceUrl"]);
+            Assert.Equal("api.example.com", config["Host"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionProjectsSectionReferenceChildren()
+        {
+            var config = new ConfigurationManager();
+            IConfigurationBuilder builder = config;
+
+            builder.AddInMemoryCollection(new Dictionary<string, string>
+            {
+                ["Defaults:Feature:Enabled"] = "true",
+                ["Feature"] = "ref(Defaults:Feature)",
+            });
+            builder.EnableReferenceResolution();
+
+            Assert.Null(config["Feature"]);
+            Assert.Equal("true", config["Feature:Enabled"]);
+            Assert.Equal("Enabled", config.GetSection("Feature").GetChildren().Single().Key);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionProjectsNestedSectionReferenceChildren()
+        {
+            var config = new ConfigurationManager();
+            IConfigurationBuilder builder = config;
+
+            builder.AddInMemoryCollection(new Dictionary<string, string>
+            {
+                ["Defaults:Feature:Nested:Enabled"] = "true",
+                ["Feature"] = "ref(Defaults:Feature)",
+            });
+            builder.EnableReferenceResolution();
+
+            Assert.Equal("true", config["Feature:Nested:Enabled"]);
+            Assert.Equal("Enabled", config.GetSection("Feature:Nested").GetChildren().Single().Key);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionKeepsSingleTokenReferenceAsLeafWhenTargetIsValue()
+        {
+            var config = new ConfigurationManager();
+            IConfigurationBuilder builder = config;
+
+            builder.AddInMemoryCollection(new Dictionary<string, string>
+            {
+                ["Defaults:Feature"] = "feature-default",
+                ["Feature"] = "ref(Defaults:Feature)",
+            });
+            builder.EnableReferenceResolution();
+
+            Assert.Equal("feature-default", config["Feature"]);
+            Assert.Null(config["Feature:Enabled"]);
+            Assert.Empty(config.GetSection("Feature").GetChildren());
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionAliasHidesEarlierChildrenUnderAliasedSection()
+        {
+            var config = new ConfigurationManager();
+            IConfigurationBuilder builder = config;
+
+            builder.AddInMemoryCollection(new Dictionary<string, string>
+            {
+                ["Feature:Legacy"] = "from-early-provider",
+                ["Defaults:Feature:Enabled"] = "from-defaults",
+            });
+            builder.AddInMemoryCollection(new Dictionary<string, string>
+            {
+                ["Feature"] = "ref(Defaults:Feature)",
+            });
+            builder.EnableReferenceResolution();
+
+            Assert.Null(config["Feature:Legacy"]);
+            Assert.Equal(
+                new[] { "Enabled" },
+                config.GetSection("Feature").GetChildren().Select(c => c.Key).OrderBy(k => k));
+        }
+
         [Fact]
         public void DisposesProvidersOnDispose()
         {
@@ -1249,6 +1390,34 @@ public TestConfigurationProvider(string key, string value)
                 => Data.Add(key, value);
         }
 
+        private sealed class LoadCountingSource : IConfigurationSource
+        {
+            private readonly IConfigurationProvider _provider;
+
+            public LoadCountingSource(IConfigurationProvider provider) => _provider = provider;
+
+            public IConfigurationProvider Build(IConfigurationBuilder builder) => _provider;
+        }
+
+        private sealed class LoadCountingProvider : ConfigurationProvider
+        {
+            private readonly IDictionary<string, string> _seed;
+
+            public LoadCountingProvider(IDictionary<string, string> seed) => _seed = seed;
+
+            public int LoadCount { get; private set; }
+
+            public override void Load()
+            {
+                LoadCount++;
+                Data.Clear();
+                foreach (KeyValuePair<string, string> kv in _seed)
+                {
+                    Data[kv.Key] = kv.Value;
+                }
+            }
+        }
+
         private class BlockLoadOnMREProvider : ConfigurationProvider
         {
             private readonly ManualResetEventSlim _mre;
diff --git a/src/libraries/Microsoft.Extensions.Configuration/tests/ConfigurationTest.cs b/src/libraries/Microsoft.Extensions.Configuration/tests/ConfigurationTest.cs
index 94ba8c20a9686c..6de7b6f4d52e89 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/tests/ConfigurationTest.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration/tests/ConfigurationTest.cs
@@ -602,6 +602,924 @@ public void SetValueThrowsExceptionNoSourceRegistered()
             Assert.Equal(expectedMsg, ex.Message);
         }
 
+        [Fact]
+        public void ReferenceResolutionIsDisabledByDefault()
+        {
+            // Sources default to ReferenceMode.Read, which leaves their own ref(...)/format(...)
+            // values verbatim. The engine attaches only when at least one source is set to Scan.
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["BaseUrl"] = "https://example.com",
+                    ["ServiceUrl"] = "format({BaseUrl}/api)",
+                })
+                .Build();
+
+            Assert.Equal("format({BaseUrl}/api)", config["ServiceUrl"]);
+        }
+
+        [Fact]
+        public void ReferenceResolutionCanBeDisabledByMarkingAllSourcesRead()
+        {
+            var memSource = new MemoryConfigurationSource
+            {
+                InitialData = new Dictionary<string, string>
+                {
+                    ["BaseUrl"] = "https://example.com",
+                    ["ServiceUrl"] = "format({BaseUrl}/api)",
+                },
+            };
+
+            var config = new ConfigurationBuilder()
+                .Add(memSource)
+                .SetReferenceMode(memSource, ReferenceMode.Read)
+                .Build();
+
+            Assert.Equal("format({BaseUrl}/api)", config["ServiceUrl"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionResolvesValues()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["BaseUrl"] = "https://example.com",
+                    ["ServiceUrl"] = "format({BaseUrl}/api)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("https://example.com/api", config["ServiceUrl"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionUsesLastProviderValue()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Environment"] = "development",
+                    ["ServiceUrl"] = "format(https://{Environment}.example.com)",
+                })
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Environment"] = "production",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("https://production.example.com", config["ServiceUrl"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionThrowsWhenRequiredReferenceIsMissing()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["ServiceUrl"] = "format(https://{Host}.example.com)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Throws<KeyNotFoundException>(() => _ = config["ServiceUrl"]);
+        }
+
+        [Theory]
+        // Inside format(...), `{{` and `}}` are composite-format-style escapes for literal `{` and `}`.
+        // A single `{...}` is a placeholder.
+        [InlineData("format({{Host}})", "{Host}")]
+        [InlineData("format(prefix-{{Host}}-suffix)", "prefix-{Host}-suffix")]
+        [InlineData("format({{A}}-{Host}-{{B}})", "{A}-my-host-{B}")]
+        // A `$` outside a placeholder is just a literal.
+        [InlineData("format($ref(Host))", "$ref(Host)")]
+        [InlineData("format(It costs ${Host})", "It costs $my-host")]
+        [InlineData("format({{}})", "{}")]
+        public void EnableReferenceResolutionTreatsEscapeBlockAsLiteral(string raw, string expected)
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Host"] = "my-host",
+                    ["Value"] = raw,
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal(expected, config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionProjectsSectionReferenceChildren()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Defaults:Feature:Enabled"] = "true",
+                    ["Defaults:Feature:Name"] = "feature-default",
+                    ["Feature"] = "ref(Defaults:Feature)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Null(config["Feature"]);
+            Assert.Equal("true", config["Feature:Enabled"]);
+            Assert.Equal("feature-default", config["Feature:Name"]);
+            Assert.Equal(
+                new[] { "Enabled", "Name" },
+                config.GetSection("Feature").GetChildren().Select(c => c.Key).OrderBy(k => k));
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionProjectsNestedSectionReferenceChildren()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Defaults:Feature:Nested:Enabled"] = "true",
+                    ["Feature"] = "ref(Defaults:Feature)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("true", config["Feature:Nested:Enabled"]);
+            Assert.Equal("Enabled", config.GetSection("Feature:Nested").GetChildren().Single().Key);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionKeepsSingleTokenReferenceAsLeafWhenTargetIsValue()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Defaults:Feature"] = "feature-default",
+                    ["Feature"] = "ref(Defaults:Feature)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("feature-default", config["Feature"]);
+            Assert.Null(config["Feature:Enabled"]);
+            Assert.Empty(config.GetSection("Feature").GetChildren());
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionOverridesValuesBeforeSectionReferenceProvider()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Feature:Enabled"] = "from-early-provider",
+                    ["Defaults:Feature:Enabled"] = "from-defaults",
+                })
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Feature"] = "ref(Defaults:Feature)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("from-defaults", config["Feature:Enabled"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionResolvesTokenViaAncestorSectionAlias()
+        {
+            // ref(Services:Primary:Host) inside the ConnectionString template must follow the section alias just like a
+            // direct read of config["Services:Primary:Host"] would.
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Defaults:Service:Host"] = "primary.example.com",
+                    ["Defaults:Service:Port"] = "5432",
+                    ["Services:Primary"] = "ref(Defaults:Service)",
+                    ["ConnectionString"] = "format({Services:Primary:Host}:{Services:Primary:Port})",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("primary.example.com:5432", config["ConnectionString"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionTokenViaAncestorAliasRespectsShadowing()
+        {
+            // Alias at a later provider shadows a direct value at an earlier provider, both for
+            // direct reads and for tokens embedded in values.
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Services:Primary:Host"] = "direct-literal",
+                    ["Defaults:Service:Host"] = "aliased-target",
+                })
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Services:Primary"] = "ref(Defaults:Service)",
+                    ["ConnectionString"] = "format(host={Services:Primary:Host})",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("aliased-target", config["Services:Primary:Host"]);
+            Assert.Equal("host=aliased-target", config["ConnectionString"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionAliasHidesEarlierChildrenUnderAliasedSection()
+        {
+            // Section aliases are always strict: children at the alias path from earlier providers
+            // do not merge into the aliased section.
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Feature:Legacy"] = "from-early-provider",
+                    ["Defaults:Feature:Enabled"] = "from-defaults",
+                })
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Feature"] = "ref(Defaults:Feature)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Null(config["Feature:Legacy"]);
+            Assert.Equal("from-defaults", config["Feature:Enabled"]);
+            Assert.Equal(
+                new[] { "Enabled" },
+                config.GetSection("Feature").GetChildren().Select(c => c.Key).OrderBy(k => k));
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionAliasAllowsLaterProviderToShadow()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Feature:Legacy"] = "from-early-provider",
+                    ["Defaults:Feature:Enabled"] = "from-defaults",
+                })
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Feature"] = "ref(Defaults:Feature)",
+                })
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Feature:Extra"] = "from-late-provider",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Null(config["Feature:Legacy"]);
+            Assert.Equal("from-defaults", config["Feature:Enabled"]);
+            Assert.Equal("from-late-provider", config["Feature:Extra"]);
+            Assert.Equal(
+                new[] { "Enabled", "Extra" },
+                config.GetSection("Feature").GetChildren().Select(c => c.Key).OrderBy(k => k));
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionPreservesValuesAfterSectionReferenceProvider()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Defaults:Feature:Enabled"] = "from-defaults",
+                })
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Feature"] = "ref(Defaults:Feature)",
+                })
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Feature:Enabled"] = "from-late-provider",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("from-late-provider", config["Feature:Enabled"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionThrowsWhenInterpolatedReferenceTargetsSection()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Defaults:Feature:Enabled"] = "true",
+                    ["Feature"] = "format(prefix-{Defaults:Feature})",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Throws<InvalidOperationException>(() => _ = config["Feature"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionAppliesToAllSourcesRegardlessOfOrder()
+        {
+            // EnableReferenceResolution is a root-level signal, not a source. Sources added
+            // after the call still participate in substitution.
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["ServiceUrl"] = "format(https://{Host??}fallback)",
+                })
+                .EnableReferenceResolution()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Host"] = "api.example.com",
+                })
+                .Build();
+
+            Assert.Equal("https://api.example.comfallback", config["ServiceUrl"]);
+            Assert.Equal("api.example.com", config["Host"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionIsIdempotent()
+        {
+            // Calling EnableReferenceResolution repeatedly keeps the single shared engine;
+            // there is no longer a per-call resolution "horizon".
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["name"] = "Alice",
+                    ["greeting"] = "format(Hello {name})",
+                })
+                .EnableReferenceResolution()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["name"] = "Bob",
+                    ["farewell"] = "format(Bye {name})",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("Bob", config["name"]);
+            Assert.Equal("Hello Bob", config["greeting"]);
+            Assert.Equal("Bye Bob", config["farewell"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionEscapeIsStillALiteral()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Template"] = "format({{hidden}})",
+                    ["hidden"] = "secret",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("{hidden}", config["Template"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionOptionalChainCollapsesToEmpty()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["ServiceUrl"] = "format(https://host{Suffix??})",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("https://host", config["ServiceUrl"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionChainTriesReferencesInOrder()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Primary"] = "first",
+                    ["Secondary"] = "second",
+                    ["Fallback"] = "fallback",
+                    ["A"] = "ref(Missing?Primary)",
+                    ["B"] = "ref(Missing?AlsoMissing?Secondary)",
+                    ["C"] = "ref(Missing?AlsoMissing?Fallback)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("first", config["A"]);
+            Assert.Equal("second", config["B"]);
+            Assert.Equal("fallback", config["C"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionChainFirstPresentWins()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Primary"] = "primary-value",
+                    ["Secondary"] = "secondary-value",
+                    ["Fallback"] = "fallback",
+                    ["Value"] = "ref(Primary?Secondary?Fallback)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("primary-value", config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionOptionalChainWithAllMissingCollapsesToEmpty()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Value"] = "ref(A?B?C??)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("", config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionOptionalChainPrefersFirstResolvedReference()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Primary"] = "hit",
+                    ["Value"] = "ref(Missing?Primary??)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("hit", config["Value"]);
+        }
+
+        [Theory]
+        [InlineData("ref()")]
+        [InlineData("ref( )")]
+        [InlineData("ref(?A)")]
+        [InlineData("ref(??)")]
+        [InlineData("ref(A?)")]
+        [InlineData("ref(A?B?)")]
+        public void EnableReferenceResolutionMalformedExpressionThrows(string raw)
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Value"] = raw,
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Throws<FormatException>(() => _ = config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionEmptyDefaultYieldsEmpty()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Value"] = "ref(NonExistent??)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal(string.Empty, config["Value"]);
+        }
+
+        [Theory]
+        [InlineData("ref('weird?key')", "weird?key")]
+        [InlineData("ref('has(paren')", "has(paren")]
+        [InlineData("ref('has)paren')", "has)paren")]
+        [InlineData("ref(\"weird:key\")", "weird:key")]
+        [InlineData("ref('it''s')", "it's")]
+        [InlineData("ref(\"say \"\"hi\"\"\")", "say \"hi\"")]
+        public void EnableReferenceResolutionQuotedMemberReferencesLiteralKey(string raw, string literalKey)
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    [literalKey] = "hit",
+                    ["Value"] = raw,
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("hit", config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionQuotedMemberInChainPicksFallback()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["odd:key"] = "fallback",
+                    ["Value"] = "ref(NotPresent?\"odd:key\")",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("fallback", config["Value"]);
+        }
+
+        [Theory]
+        [InlineData("format(  hello  )", "hello")]
+        [InlineData("format(\"  hello  \")", "  hello  ")]
+        [InlineData("format('  hello  ')", "  hello  ")]
+        [InlineData("format()", "")]
+        [InlineData("format(   )", "")]
+        [InlineData("format('')", "")]
+        [InlineData("format(  {Key}  )", "value")]
+        [InlineData("format('  {Key}  ')", "  value  ")]
+        [InlineData("format('it''s')", "it's")]
+        [InlineData("format('has)paren')", "has)paren")]
+        public void EnableReferenceResolutionFormatBodyTrimOrQuote(string raw, string expected)
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Key"] = "value",
+                    ["Value"] = raw,
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal(expected, config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionQuotedKeyInFormatPlaceholderResolves()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["odd?key"] = "value",
+                    ["Greeting"] = "format(Hello, {'odd?key'}!)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("Hello, value!", config["Greeting"]);
+        }
+
+        [Theory]
+        [InlineData("ref(Missing??quoted default)", "quoted default")]
+        [InlineData("ref(Missing??has}}brace)", "has}brace")]
+        [InlineData("ref(Missing??  spaced  )", "spaced")]
+        [InlineData("ref(Missing??\"  spaced  \")", "  spaced  ")]
+        [InlineData("ref(Missing??'  spaced  ')", "  spaced  ")]
+        [InlineData("ref(Missing??'it''s')", "it's")]
+        [InlineData("ref(Missing??\"plain\")", "plain")]
+        [InlineData("ref(Missing??'has)paren')", "has)paren")]
+        [InlineData("ref(Missing??)", "")]
+        [InlineData("ref(Missing??'')", "")]
+        public void EnableReferenceResolutionDefaultLiteralTail(string raw, string expected)
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Value"] = raw,
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal(expected, config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionDefaultTailWithBraceInsideFmtPlaceholder()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    // Inside a {…} placeholder of an outer format(…), the chain's '??' switches
+                    // its remainder into template-mode where '}}' is the escape for literal '}'.
+                    ["Template"] = "format(prefix-{Missing??has}}brace}-suffix)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("prefix-has}brace-suffix", config["Template"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionDefaultTailIsTemplateWithPlaceholder()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Host"] = "example.com",
+                    ["Value"] = "ref(Missing??{Host}/path)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("example.com/path", config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionDefaultTailComposesCoalesceAndLiteral()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Backup"] = "bee",
+                    ["Value"] = "ref(Missing??{Unknown?Backup??fallback}-end)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("bee-end", config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionDefaultTailFallsBackToInnerLiteralWhenAllMiss()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Value"] = "ref(Missing??{Unknown?AlsoUnknown??inner}-end)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("inner-end", config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionFmtPlaceholderWithNestedDefault()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["B"] = "bee",
+                    ["Value"] = "format(prefix-{A??{B}}-suffix)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("prefix-bee-suffix", config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionDefaultTailQuotedBraceIsLiteralNotPlaceholder()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Host"] = "should-not-appear",
+                    // Default template with `{{` `}}` brace-doublings emits literal `{Host}`.
+                    ["Value"] = "ref(Missing??{{Host}})",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("{Host}", config["Value"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionRelativeRefSiblingResolves()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Services:Billing:Host"] = "billing.example.com",
+                    ["Services:Billing:Url"] = "format(https://{..:Host}/api)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("https://billing.example.com/api", config["Services:Billing:Url"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionRelativeRefUncleResolves()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["App:Shared:Region"] = "eu-west",
+                    ["App:Services:Billing:Zone"] = "ref(..:..:..:Shared:Region)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            // Three hops up from App:Services:Billing:Zone = App, then :Shared:Region.
+            Assert.Equal("eu-west", config["App:Services:Billing:Zone"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionRelativeRefAnchorsAtStorageNotQuery()
+        {
+            // A section alias maps Services:Billing onto the Defaults subtree. A relative ref
+            // inside a Defaults value must resolve relative to its storage key (Defaults:Db:Conn),
+            // not relative to the user-facing query key (Services:Billing:Db:Conn).
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Defaults:Db:Host"] = "defaults-db-host",
+                    ["Defaults:Db:Conn"] = "ref(..:Host)",
+                    ["Services:Billing:Db:Host"] = "billing-db-host",
+                    ["Services:Billing"] = "ref(Defaults)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            // ..:Host anchors at Defaults:Db (storage), so it picks Defaults:Db:Host even when
+            // queried via the aliased path. The user's Services:Billing:Db:Host value (which
+            // exists at the query side) is irrelevant to this resolution.
+            Assert.Equal("defaults-db-host", config["Services:Billing:Db:Conn"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionRelativeRefAboveRootFallsThroughChain()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Fallback"] = "fallback-value",
+                    ["TopLevel"] = "ref(..:..:DoesNotExist?Fallback)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            // The relative ref wants two parents above a 1-segment key; that fails, chain falls
+            // through to the absolute Fallback reference.
+            Assert.Equal("fallback-value", config["TopLevel"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionRelativeRefAboveRootOptionalYieldsEmpty()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["TopLevel"] = "format(prefix-{..:..:Nothing??}-suffix)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("prefix--suffix", config["TopLevel"]);
+        }
+
+        [Fact]
+        public void EnableReferenceResolutionRelativeRefPureParentResolvesSection()
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Defaults:Host"] = "h",
+                    ["Defaults:Port"] = "p",
+                    ["Services:Db"] = "ref(..:..:Defaults)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            // ..:..:Defaults from Services:Db = Defaults (section). Rebase exposes its children.
+            Assert.Equal("h", config["Services:Db:Host"]);
+            Assert.Equal("p", config["Services:Db:Port"]);
+        }
+
+        [Theory]
+        [InlineData("ref(A:..:B)")]
+        [InlineData("ref(A:..)")]
+        public void EnableReferenceResolutionRelativeSegmentNotAtStartThrows(string raw)
+        {
+            var config = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["Value"] = raw,
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Throws<FormatException>(() => _ = config["Value"]);
+        }
+
+        [Fact]
+        public void ConfigureReferenceResolutionOnEmptyBuilderThrows()
+        {
+            var builder = new ConfigurationBuilder();
+
+            Assert.Throws<InvalidOperationException>(() => builder.ConfigureReferenceResolution(ReferenceMode.Ignore));
+        }
+
+        [Fact]
+        public void ConfigureReferenceResolutionIgnoreHidesValuesFromSubstitution()
+        {
+            var hiddenSource = new MemoryConfigurationSource
+            {
+                InitialData = new Dictionary<string, string> { ["X"] = "from-hidden" }
+            };
+
+            var config = new ConfigurationBuilder()
+                .Add(hiddenSource)
+                .ConfigureReferenceResolution(ReferenceMode.Ignore)
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["K"] = "ref(X)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Throws<KeyNotFoundException>(() => _ = config["K"]);
+            Assert.Equal("from-hidden", config["X"]);
+        }
+
+        [Fact]
+        public void ConfigureReferenceResolutionBySourceNoneHidesValuesFromSubstitution()
+        {
+            var hiddenSource = new MemoryConfigurationSource
+            {
+                InitialData = new Dictionary<string, string> { ["X"] = "from-hidden" }
+            };
+            var builder = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["K"] = "ref(X)",
+                })
+                .EnableReferenceResolution();
+
+            builder.Add(hiddenSource);
+            builder.ConfigureReferenceResolution(hiddenSource, ReferenceMode.Ignore);
+
+            IConfigurationRoot config = builder.Build();
+
+            Assert.Throws<KeyNotFoundException>(() => _ = config["K"]);
+            Assert.Equal("from-hidden", config["X"]);
+        }
+
+        [Fact]
+        public void ConfigureReferenceResolutionBySourceNotPresentThrows()
+        {
+            var builder = new ConfigurationBuilder().AddInMemoryCollection();
+            var otherSource = new MemoryConfigurationSource();
+
+            Assert.Throws<ArgumentException>(() => builder.ConfigureReferenceResolution(otherSource, ReferenceMode.Ignore));
+        }
+
+        [Fact]
+        public void ConfigureReferenceResolutionIgnoreChildrenStillVisibleInGetChildren()
+        {
+            var hiddenSource = new MemoryConfigurationSource
+            {
+                InitialData = new Dictionary<string, string>
+                {
+                    ["Section:A"] = "a",
+                    ["Section:B"] = "b",
+                }
+            };
+
+            var config = new ConfigurationBuilder()
+                .Add(hiddenSource)
+                .ConfigureReferenceResolution(ReferenceMode.Ignore)
+                .EnableReferenceResolution()
+                .Build();
+
+            IEnumerable<string> childKeys = config.GetSection("Section").GetChildren().Select(c => c.Key).OrderBy(k => k);
+            Assert.Equal(new[] { "A", "B" }, childKeys);
+        }
+
+        [Fact]
+        public void ConfigureReferenceResolutionReadTreatsOwnValuesAsLiteralButServesAsTarget()
+        {
+            // Source in Read-only mode is a substitution target but its own ref(...)/format(...) values stay literal.
+            var readOnlySource = new MemoryConfigurationSource
+            {
+                InitialData = new Dictionary<string, string>
+                {
+                    ["X"] = "from-readonly",
+                    ["Self"] = "ref(X)",
+                }
+            };
+
+            var config = new ConfigurationBuilder()
+                .Add(readOnlySource)
+                .ConfigureReferenceResolution(ReferenceMode.Read)
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    ["K"] = "ref(X)",
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            Assert.Equal("from-readonly", config["K"]);
+            Assert.Equal("ref(X)", config["Self"]);
+        }
+
+        private sealed class StubBuilder : IConfigurationBuilder
+        {
+            public IDictionary<string, object> Properties { get; } = new Dictionary<string, object>();
+            public IList<IConfigurationSource> Sources { get; } = new List<IConfigurationSource>();
+            public IConfigurationBuilder Add(IConfigurationSource source) { Sources.Add(source); return this; }
+            public IConfigurationRoot Build() => throw new NotImplementedException();
+        }
+
         [Fact]
         public void SameReloadTokenIsReturnedRepeatedly()
         {
diff --git a/src/libraries/Microsoft.Extensions.Configuration/tests/FunctionalTests/ConfigurationTests.cs b/src/libraries/Microsoft.Extensions.Configuration/tests/FunctionalTests/ConfigurationTests.cs
index f6bbb5adc056e5..df56a78aae4cea 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/tests/FunctionalTests/ConfigurationTests.cs
+++ b/src/libraries/Microsoft.Extensions.Configuration/tests/FunctionalTests/ConfigurationTests.cs
@@ -1018,6 +1018,79 @@ private sealed class MyOptions
             public string XmlKey1 { get; set; }
         }
 
+        [Fact]
+        public void ReferenceResolution_RealWorldScenario_CombinesSectionAliasOverridesAndTokenSyntax()
+        {
+            // appsettings.json provides defaults, including a Services template ("Defaults:Service") that
+            // will be reused via a section alias.
+            _fileSystem.WriteFile(_jsonFile, @"{
+  ""Environment"": ""Staging"",
+  ""Defaults"": {
+    ""Service"": {
+      ""Host"": ""primary.example.com"",
+      ""Port"": ""5432"",
+      ""Protocol"": ""tcp""
+    }
+  },
+  ""Services"": {
+    ""Primary"": ""ref(Defaults:Service)""
+  },
+  ""ConnectionString"": ""format({Services:Primary:Protocol}://{User}@{Services:Primary:Host}:{Services:Primary:Port}/{Database?Defaults:Database})"",
+  ""Tracing"": {
+    ""Collector"": ""ref(Tracing:Endpoint??)""
+  },
+  ""Defaults"": {
+    ""Database"": ""appdb""
+  },
+  ""Metadata"": {
+    ""Literal"": ""ref(do-not-interpret)""
+  }
+}");
+
+            // INI layered on top of the JSON. It supplies the User secret and, critically, overrides a
+            // single child of the aliased section (Services:Primary:Port) at a LATER provider than the
+            // alias itself. This validates that provider-order overrides still win over alias projection.
+            _fileSystem.WriteFile(_iniFile, @"User = admin
+[Services:Primary]
+Port = 6543");
+
+            var config = CreateBuilder()
+                .AddJsonFile(_jsonFile, optional: false, reloadOnChange: false)
+                .AddIniFile(_iniFile, optional: false, reloadOnChange: false)
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    // Exercises ref(Key?Fallback) — the key isn't present so the fallback reference ("Defaults:Database") applies.
+                    // We intentionally don't set "Database" anywhere else in the chain.
+                })
+                .EnableReferenceResolution()
+                .Build();
+
+            // Section alias projects the Defaults:Service children under Services:Primary...
+            Assert.Equal("primary.example.com", config["Services:Primary:Host"]);
+            Assert.Equal("tcp", config["Services:Primary:Protocol"]);
+
+            // ...but the INI override (later provider) shadows a single child.
+            Assert.Equal("6543", config["Services:Primary:Port"]);
+
+            // GetChildren surfaces the union of alias-projected keys and overlaid keys, with no duplicates.
+            string[] primaryChildren = config.GetSection("Services:Primary")
+                .GetChildren()
+                .Select(c => c.Key)
+                .OrderBy(k => k, StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+            Assert.Equal(new[] { "Host", "Port", "Protocol" }, primaryChildren);
+
+            // Multi-token interpolation composes across JSON (aliased), INI (override + secret), and a
+            // default-value token — the single ConnectionString pulls from three providers at once.
+            Assert.Equal("tcp://admin@primary.example.com:6543/appdb", config["ConnectionString"]);
+
+            // Optional ref(Tracing:Endpoint??) resolves to an empty string because the key is missing.
+            Assert.Equal(string.Empty, config["Tracing:Collector"]);
+
+            // A gated value whose key cannot be resolved and has no default throws.
+            Assert.Throws<KeyNotFoundException>(() => _ = config["Metadata:Literal"]);
+        }
+
         private async Task WatchOverConfigJsonFileAndUpdateIt(string filePath)
         {
             var builder = new ConfigurationBuilder().AddJsonFile(filePath, true, true).Build();
diff --git a/src/libraries/Microsoft.Extensions.Configuration/tests/FunctionalTests/Microsoft.Extensions.Configuration.Functional.Tests.csproj b/src/libraries/Microsoft.Extensions.Configuration/tests/FunctionalTests/Microsoft.Extensions.Configuration.Functional.Tests.csproj
index d23ce8155b6251..d4ecb9fcddcc69 100644
--- a/src/libraries/Microsoft.Extensions.Configuration/tests/FunctionalTests/Microsoft.Extensions.Configuration.Functional.Tests.csproj
+++ b/src/libraries/Microsoft.Extensions.Configuration/tests/FunctionalTests/Microsoft.Extensions.Configuration.Functional.Tests.csproj
@@ -7,6 +7,7 @@
 
   <ItemGroup>
     <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\Common\ConfigurationProviderExtensions.cs" Link="Common\ConfigurationProviderExtensions.cs" />
+    <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\ReferenceResolutionTestShims.cs" Link="ReferenceResolutionTestShims.cs" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/libraries/Microsoft.Extensions.Configuration/tests/ReferenceResolutionTestShims.cs b/src/libraries/Microsoft.Extensions.Configuration/tests/ReferenceResolutionTestShims.cs
new file mode 100644
index 00000000000000..f78db93fbc4060
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Configuration/tests/ReferenceResolutionTestShims.cs
@@ -0,0 +1,49 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Microsoft.Extensions.Configuration
+{
+    // Test-only compatibility shim mapping the legacy EnableReferenceResolution / ConfigureReferenceResolution
+    // names to SetReferenceMode. Keeps the large test suite compiling without per-call rewrites.
+    internal static class ReferenceResolutionTestShims
+    {
+        public static IConfigurationBuilder EnableReferenceResolution(this IConfigurationBuilder builder)
+        {
+            ArgumentNullException.ThrowIfNull(builder);
+
+            // Apply Scan only to sources that haven't already been assigned a mode, so earlier
+            // ConfigureReferenceResolution(mode) / ConfigureReferenceResolution(source, mode) calls
+            // remain in effect.
+            const string SourceModesPropertyName = "Microsoft.Extensions.Configuration.ReferenceResolution.SourceModes";
+            var existing = builder.Properties.TryGetValue(SourceModesPropertyName, out object? raw)
+                ? raw as System.Collections.IDictionary
+                : null;
+            foreach (IConfigurationSource source in builder.Sources)
+            {
+                if (existing is null || !existing.Contains(source))
+                {
+                    builder.SetReferenceMode(source, ReferenceMode.Scan);
+                }
+            }
+            return builder;
+        }
+
+        // Marks every currently-added source as Scan. Tests that use this pair it with the most-recently
+        // added source; since SetReferenceMode(source, ...) is used where targeting is needed, the
+        // default overload marks all sources as Scan.
+        public static IConfigurationBuilder ConfigureReferenceResolution(this IConfigurationBuilder builder, ReferenceMode mode)
+        {
+            ArgumentNullException.ThrowIfNull(builder);
+            if (builder.Sources.Count == 0)
+            {
+                throw new InvalidOperationException("No sources.");
+            }
+            return builder.SetReferenceMode(builder.Sources[builder.Sources.Count - 1], mode);
+        }
+
+        public static IConfigurationBuilder ConfigureReferenceResolution(this IConfigurationBuilder builder, IConfigurationSource source, ReferenceMode mode)
+            => builder.SetReferenceMode(source, mode);
+    }
+}