From ed74bf20459ff61fc0767acdd74982d571d2ef6d Mon Sep 17 00:00:00 2001
From: Rex Morgan <rex@rexmorgan.net>
Date: Sat, 20 Jun 2026 12:35:56 -0400
Subject: [PATCH 1/2] fix: WriteSafeString encoding consistent regardless of
 registration order (issue #559)

When a helper with no arguments (e.g. {{link_to}}) was registered after
Compile(), the parser treated it as a PathExpression rather than a
HelperExpression. PathBinder.VisitPathExpression emitted code calling the
object-returning Invoke overload, whose return value was then passed to
EncodedTextWriter.Write<object> which always HTML-encodes strings. This
meant that WriteSafeString() output was re-encoded, producing &lt;a&gt;
instead of <a>.

When the same helper was registered before Compile(), HelperConverter
recognised the name and produced a HelperExpression; HelperFunctionBinder
then emitted the void Invoke(EncodedTextWriter,...) overload which writes
directly to the output writer and preserves WriteSafeString semantics.

Fix: in PathBinder.VisitStatementExpression, detect PathExpressions that
are valid helper literals (the ambiguous name-only case) and emit the same
void Invoke(writer,...) call that HelperFunctionBinder would have produced.
A LateBindHelperDescriptor Ref<> is registered in configuration.Helpers so
that a subsequent RegisterHelper() call updates the Ref in-place, exactly
as the HelperFunctionBinder late-binding mechanism does.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../Handlebars.Test/Issues/Issue559Tests.cs   | 44 +++++++++++++++++++
 .../Translation/Expression/PathBinder.cs      | 39 +++++++++++++++-
 2 files changed, 81 insertions(+), 2 deletions(-)
 create mode 100644 source/Handlebars.Test/Issues/Issue559Tests.cs

diff --git a/source/Handlebars.Test/Issues/Issue559Tests.cs b/source/Handlebars.Test/Issues/Issue559Tests.cs
new file mode 100644
index 00000000..2f0b2c8e
--- /dev/null
+++ b/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);
+        }
+    }
+}
diff --git a/source/Handlebars/Compiler/Translation/Expression/PathBinder.cs b/source/Handlebars/Compiler/Translation/Expression/PathBinder.cs
index 33d1b232..e1d261a7 100644
--- a/source/Handlebars/Compiler/Translation/Expression/PathBinder.cs
+++ b/source/Handlebars/Compiler/Translation/Expression/PathBinder.cs
@@ -18,10 +18,45 @@ public PathBinder(CompilationContext compilationContext)
         
         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 (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));
         }

From 746652037e40ea6b3721605da2608b0a11165d13 Mon Sep 17 00:00:00 2001
From: Rex Morgan <rex@rexmorgan.net>
Date: Sat, 20 Jun 2026 18:22:50 -0400
Subject: [PATCH 2/2] fix: resolve case-sensitive path variables independently
 in PathBinder (issue #434)

The Helpers dictionary uses a case-insensitive PathInfoLight comparer, so
{{TEST}} and {{test}} previously resolved to the same LateBindHelperDescriptor
entry. When the second expression was compiled it reused the first descriptor
(keyed to the wrong case), causing both to bind to the same property at
runtime. Fix detects when a found entry is a LateBindHelperDescriptor for a
differently-cased path and creates a fresh descriptor for the exact path, so
each case variant resolves independently at runtime.

Adds Issue434Tests.cs to exercise the failing scenario.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../Handlebars.Test/Issues/Issue434Tests.cs   | 20 +++++++++++++++++++
 .../Translation/Expression/PathBinder.cs      | 10 ++++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 source/Handlebars.Test/Issues/Issue434Tests.cs

diff --git a/source/Handlebars.Test/Issues/Issue434Tests.cs b/source/Handlebars.Test/Issues/Issue434Tests.cs
new file mode 100644
index 00000000..ffe875b1
--- /dev/null
+++ b/source/Handlebars.Test/Issues/Issue434Tests.cs
@@ -0,0 +1,20 @@
+using System.Dynamic;
+using Xunit;
+
+namespace HandlebarsDotNet.Test
+{
+    public class Issue434Tests
+    {
+        [Fact]
+        public void Issue434_CaseSensitiveLookupWithSameSpellingVariables()
+        {
+            var h = Handlebars.Create();
+            var template = h.Compile("{{TEST}} {{test}}");
+            dynamic data = new ExpandoObject();
+            data.TEST = "Upper";
+            data.test = "Lower";
+            var result = template(data);
+            Assert.Equal("Upper Lower", result);
+        }
+    }
+}
diff --git a/source/Handlebars/Compiler/Translation/Expression/PathBinder.cs b/source/Handlebars/Compiler/Translation/Expression/PathBinder.cs
index e1d261a7..e77608c6 100644
--- a/source/Handlebars/Compiler/Translation/Expression/PathBinder.cs
+++ b/source/Handlebars/Compiler/Translation/Expression/PathBinder.cs
@@ -37,6 +37,16 @@ protected override Expression VisitStatementExpression(StatementExpression sex)
                     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();