fix: WriteSafeString encoding consistent regardless of registration order (issue #559)

source/Handlebars.Test/Issues/Issue434Tests.cs

@@ -14,9 +14,7 @@ public void Issue434_CaseSensitiveLookupWithSameSpellingVariables()
             data.TEST = "Upper";
             data.test = "Lower";
             var result = template(data);
-            var parts = result.Split(' ');
-            Assert.Equal("Upper", parts[0]);
-            Assert.Equal("Lower", parts[1]);
+            Assert.Equal("Upper Lower", result);
         }
     }
 }

source/Handlebars.Test/Issues/Issue559Tests.cs

@@ -0,0 +1,44 @@
+using Xunit;
+using Xunit.Abstractions;
+
+namespace HandlebarsDotNet.Test
+{
+    public class Issue559Tests
+    {
+        private readonly ITestOutputHelper _output;
+
+        public Issue559Tests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
+        [Fact]
+        public void WriteSafeString_ConsistentRegardlessOfRegistrationOrder()
+        {
+            HandlebarsHelper link_to = (writer, context, parameters) =>
+                writer.WriteSafeString($"<a href='{context["url"]}'>{context["text"]}</a>");
+
+            string source = "Click here: {{link_to}}";
+            var data = new { url = "https://example.com", text = "Click" };
+
+            // Register BEFORE compile
+            var h1 = Handlebars.Create();
+            h1.RegisterHelper("link_to", link_to);
+            var t1 = h1.Compile(source);
+            var result1 = t1(data);
+
+            // Register AFTER compile
+            var h2 = Handlebars.Create();
+            var t2 = h2.Compile(source);
+            h2.RegisterHelper("link_to", link_to);
+            var result2 = t2(data);
+
+            _output.WriteLine($"result1 (before compile): {result1}");
+            _output.WriteLine($"result2 (after compile): {result2}");
+
+            // Both should produce identical, unescaped HTML
+            Assert.Equal(result1, result2);
+            Assert.Contains("<a href=", result1);
+        }
+    }
+}

source/Handlebars/Compiler/Translation/Expression/PathBinder.cs

@@ -18,10 +18,55 @@
 
         protected override Expression VisitStatementExpression(StatementExpression sex)
         {
-            if (!(sex.Body is PathExpression)) return Visit(sex.Body);
+            if (!(sex.Body is PathExpression pex)) return Visit(sex.Body);
+
+            var configuration = CompilationContext.Configuration;
+            var pathInfo = PathInfoStore.Current.GetOrAdd(pex.Path);
+
+            if (pex.Context != PathExpression.ResolutionContext.Parameter
+                && !pathInfo.IsVariable
+                && !pathInfo.IsThis
+                && (pathInfo.IsValidHelperLiteral || configuration.Compatibility.RelaxedHelperNaming))
+            {
+                var pathInfoLight = new PathInfoLight(pathInfo);
+                Ref<IHelperDescriptor<HelperOptions>> helper;
+
+                if (!configuration.Helpers.TryGetValue(pathInfoLight, out helper))
+                {
+                    var lateBindHelperDescriptor = new LateBindHelperDescriptor(pathInfo);
+                    helper = new Ref<IHelperDescriptor<HelperOptions>>(lateBindHelperDescriptor);
+                    configuration.Helpers.AddOrReplace(pathInfoLight, helper);
+                }
+                else if (helper.Value is LateBindHelperDescriptor existingLateBindDescriptor
+                         && !string.Equals(existingLateBindDescriptor.Name.Path, pathInfo.Path, System.StringComparison.Ordinal))
+                {
+                    // The case-insensitive lookup found a late-bind descriptor registered for a
+                    // differently-cased path (e.g. {{TEST}} was registered; now compiling {{test}}).
+                    // Create a fresh descriptor bound to the exact current path so that runtime
+                    // path resolution is case-sensitive.
+                    var lateBindHelperDescriptor = new LateBindHelperDescriptor(pathInfo);
+                    helper = new Ref<IHelperDescriptor<HelperOptions>>(lateBindHelperDescriptor);
+                }
+                else if (configuration.Compatibility.RelaxedHelperNaming)
+                {
+                    pathInfoLight = pathInfoLight.TagComparer();
+                    if (!configuration.Helpers.ContainsKey(pathInfoLight))
+                    {
+                        var lateBindHelperDescriptor = new LateBindHelperDescriptor(pathInfo);
+                        helper = new Ref<IHelperDescriptor<HelperOptions>>(lateBindHelperDescriptor);
+                        configuration.Helpers.AddOrReplace(pathInfoLight, helper);
+                    }
+                }
+
+                var bindingContext = CompilationContext.Args.BindingContext;
+                var options = New(() => new HelperOptions(pathInfo, bindingContext));
+                var contextValue = New(() => new Context(bindingContext));
+                var args = New(() => new Arguments(0));
+                var textWriter = CompilationContext.Args.EncodedWriter;
+                return Call(() => helper.Value.Invoke(textWriter, options, contextValue, args));
+            }
 
             var writer = CompilationContext.Args.EncodedWriter;
-
             var value = Arg<object>(Visit(sex.Body));
             return writer.Call(o => o.Write<object>(value));
         }
@@ -36,7 +81,7 @@
 
             if (pex.Context == PathExpression.ResolutionContext.Parameter) return resolvePath;
             if (pathInfo.IsVariable || pathInfo.IsThis) return resolvePath;
             if (!pathInfo.IsValidHelperLiteral && !configuration.Compatibility.RelaxedHelperNaming) return resolvePath;
 
             var pathInfoLight = new PathInfoLight(pathInfo);
             if (!configuration.Helpers.TryGetValue(pathInfoLight, out var helper))
@@ -56,7 +101,7 @@
                 var lateBindHelperDescriptor = new LateBindHelperDescriptor(pathInfo);
                 helper = new Ref<IHelperDescriptor<HelperOptions>>(lateBindHelperDescriptor);
             }
             else if (configuration.Compatibility.RelaxedHelperNaming)
             {
                 pathInfoLight = pathInfoLight.TagComparer();
                 if (!configuration.Helpers.ContainsKey(pathInfoLight))