From cb6beb0420536a4c42d9d9b6488be16a81f42cf9 Mon Sep 17 00:00:00 2001
From: Vaceslav Ustinov <vaceslav.ustinov@gmail.com>
Date: Wed, 7 Jan 2026 17:08:15 +0100
Subject: [PATCH 1/5] feat: add processing warnings with report generation
 (#69)

Add comprehensive warning collection during template processing:
- ProcessingWarning type with rich context (type, message, variable name, context)
- IWarningCollector interface for collecting warnings during visitor traversal
- Warnings for missing variables, missing loop collections, null loop collections
- ProcessingResult.Warnings property and HasWarnings helper

Add warning report generation:
- GetWarningReport() returns MemoryStream with formatted .docx report
- GetWarningReportBytes() returns byte array for convenience
- Uses embedded template processed by Templify itself
- WarningReportTemplateGenerator creates the embedded template

Integrate into GUI:
- Display warnings summary after template processing
- "Generate Warning Report" button to save detailed report
- Auto-opens generated report in default application

Normalize loop behavior:
- Null collections now treated same as missing (silent removal)
- Previously null collections threw exception while missing were silently removed
---
 .vscode/settings.json                         |   3 +
 .../WarningReportTemplateGenerator.cs         | 129 ++++++
 .../Program.cs                                |   1 +
 .../ViewModels/MainWindowViewModel.cs         |  74 +++-
 TriasDev.Templify.Gui/Views/MainWindow.axaml  |   4 +
 .../ProcessingWarningsIntegrationTests.cs     | 402 ++++++++++++++++++
 .../Visitors/CompositeVisitorTests.cs         |   2 +-
 .../Visitors/ConditionalVisitorTests.cs       |  20 +-
 .../Visitors/LoopVisitorTests.cs              |  59 ++-
 .../Visitors/PlaceholderVisitorTests.cs       |  22 +-
 .../Core/DocumentTemplateProcessor.cs         |  14 +-
 TriasDev.Templify/Core/IWarningCollector.cs   |  43 ++
 TriasDev.Templify/Core/ProcessingResult.cs    |  48 ++-
 TriasDev.Templify/Core/ProcessingWarning.cs   | 127 ++++++
 .../Core/WarningReportGenerator.cs            | 110 +++++
 .../Resources/WarningReportTemplate.docx      | Bin 0 -> 1596 bytes
 TriasDev.Templify/TriasDev.Templify.csproj    |   4 +
 .../Visitors/ConditionalVisitor.cs            |   4 +-
 TriasDev.Templify/Visitors/LoopVisitor.cs     |  17 +-
 .../Visitors/PlaceholderVisitor.cs            |   8 +-
 examples/outputs/warning-report-output.docx   | Bin 0 -> 1587 bytes
 .../templates/warning-report-template.docx    | Bin 0 -> 1596 bytes
 22 files changed, 1038 insertions(+), 53 deletions(-)
 create mode 100644 .vscode/settings.json
 create mode 100644 TriasDev.Templify.DocumentGenerator/Generators/WarningReportTemplateGenerator.cs
 create mode 100644 TriasDev.Templify.Tests/Integration/ProcessingWarningsIntegrationTests.cs
 create mode 100644 TriasDev.Templify/Core/IWarningCollector.cs
 create mode 100644 TriasDev.Templify/Core/ProcessingWarning.cs
 create mode 100644 TriasDev.Templify/Core/WarningReportGenerator.cs
 create mode 100644 TriasDev.Templify/Resources/WarningReportTemplate.docx
 create mode 100644 examples/outputs/warning-report-output.docx
 create mode 100644 examples/templates/warning-report-template.docx

diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..865798a
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+  "cSpell.words": ["Templify", "Trias"]
+}
diff --git a/TriasDev.Templify.DocumentGenerator/Generators/WarningReportTemplateGenerator.cs b/TriasDev.Templify.DocumentGenerator/Generators/WarningReportTemplateGenerator.cs
new file mode 100644
index 0000000..b908075
--- /dev/null
+++ b/TriasDev.Templify.DocumentGenerator/Generators/WarningReportTemplateGenerator.cs
@@ -0,0 +1,129 @@
+using DocumentFormat.OpenXml.Packaging;
+
+namespace TriasDev.Templify.DocumentGenerator.Generators;
+
+/// <summary>
+/// Generates the warning report template used by Templify to render processing warnings.
+/// This template is embedded in the main library as a resource.
+/// </summary>
+public class WarningReportTemplateGenerator : BaseExampleGenerator
+{
+    public override string Name => "warning-report";
+
+    public override string Description => "Warning report template for Templify processing warnings";
+
+    public override string GenerateTemplate(string outputDirectory)
+    {
+        var templatePath = Path.Combine(outputDirectory, $"{Name}-template.docx");
+
+        using (var doc = CreateDocument(templatePath))
+        {
+            var body = doc.MainDocumentPart!.Document.Body!;
+
+            // Title
+            AddParagraph(body, "Template Processing Warning Report", isBold: true);
+            AddEmptyParagraph(body);
+
+            // Metadata
+            AddParagraph(body, "Generated: {{GeneratedAt}}");
+            AddEmptyParagraph(body);
+
+            // Summary section
+            AddParagraph(body, "Summary", isBold: true);
+            AddParagraph(body, "Total Warnings: {{TotalWarnings}}");
+            AddEmptyParagraph(body);
+
+            // Summary table
+            var summaryTable = CreateTable(2);
+            AddTableHeaderRow(summaryTable, "Warning Type", "Count");
+            AddTableRow(summaryTable, "Missing Variables", "{{MissingVariableCount}}");
+            AddTableRow(summaryTable, "Missing Collections", "{{MissingCollectionCount}}");
+            AddTableRow(summaryTable, "Null Collections", "{{NullCollectionCount}}");
+            body.AppendChild(summaryTable);
+            AddEmptyParagraph(body);
+
+            // Missing Variables section (conditional)
+            AddParagraph(body, "{{#if HasMissingVariables}}");
+            AddParagraph(body, "Missing Variables", isBold: true);
+            AddParagraph(body, "The following variables were referenced in the template but not found in the data:");
+            AddEmptyParagraph(body);
+
+            var missingVarsTable = CreateTable(2);
+            AddTableHeaderRow(missingVarsTable, "Variable Name", "Context");
+            AddTableRow(missingVarsTable, "{{#foreach MissingVariables}}", "");
+            AddTableRow(missingVarsTable, "{{VariableName}}", "{{Context}}");
+            AddTableRow(missingVarsTable, "{{/foreach}}", "");
+            body.AppendChild(missingVarsTable);
+            AddEmptyParagraph(body);
+            AddParagraph(body, "{{/if}}");
+
+            // Missing Collections section (conditional)
+            AddParagraph(body, "{{#if HasMissingCollections}}");
+            AddParagraph(body, "Missing Loop Collections", isBold: true);
+            AddParagraph(body, "The following collections were referenced in loops but not found in the data:");
+            AddEmptyParagraph(body);
+
+            var missingCollTable = CreateTable(2);
+            AddTableHeaderRow(missingCollTable, "Collection Name", "Context");
+            AddTableRow(missingCollTable, "{{#foreach MissingCollections}}", "");
+            AddTableRow(missingCollTable, "{{VariableName}}", "{{Context}}");
+            AddTableRow(missingCollTable, "{{/foreach}}", "");
+            body.AppendChild(missingCollTable);
+            AddEmptyParagraph(body);
+            AddParagraph(body, "{{/if}}");
+
+            // Null Collections section (conditional)
+            AddParagraph(body, "{{#if HasNullCollections}}");
+            AddParagraph(body, "Null Loop Collections", isBold: true);
+            AddParagraph(body, "The following collections were found but had null values:");
+            AddEmptyParagraph(body);
+
+            var nullCollTable = CreateTable(2);
+            AddTableHeaderRow(nullCollTable, "Collection Name", "Context");
+            AddTableRow(nullCollTable, "{{#foreach NullCollections}}", "");
+            AddTableRow(nullCollTable, "{{VariableName}}", "{{Context}}");
+            AddTableRow(nullCollTable, "{{/foreach}}", "");
+            body.AppendChild(nullCollTable);
+            AddEmptyParagraph(body);
+            AddParagraph(body, "{{/if}}");
+
+            // Footer
+            AddEmptyParagraph(body);
+            AddParagraph(body, "End of Warning Report");
+
+            doc.Save();
+        }
+
+        return templatePath;
+    }
+
+    public override Dictionary<string, object> GetSampleData()
+    {
+        // Sample data for testing the template
+        return new Dictionary<string, object>
+        {
+            ["GeneratedAt"] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
+            ["TotalWarnings"] = 5,
+            ["MissingVariableCount"] = 2,
+            ["MissingCollectionCount"] = 2,
+            ["NullCollectionCount"] = 1,
+            ["HasMissingVariables"] = true,
+            ["HasMissingCollections"] = true,
+            ["HasNullCollections"] = true,
+            ["MissingVariables"] = new List<Dictionary<string, object>>
+            {
+                new() { ["VariableName"] = "CustomerName", ["Context"] = "placeholder" },
+                new() { ["VariableName"] = "Customer.Email", ["Context"] = "placeholder" }
+            },
+            ["MissingCollections"] = new List<Dictionary<string, object>>
+            {
+                new() { ["VariableName"] = "OrderItems", ["Context"] = "loop: OrderItems" },
+                new() { ["VariableName"] = "Categories", ["Context"] = "loop: Categories" }
+            },
+            ["NullCollections"] = new List<Dictionary<string, object>>
+            {
+                new() { ["VariableName"] = "Products", ["Context"] = "loop: Products" }
+            }
+        };
+    }
+}
diff --git a/TriasDev.Templify.DocumentGenerator/Program.cs b/TriasDev.Templify.DocumentGenerator/Program.cs
index 19e42f4..79f6ad6 100644
--- a/TriasDev.Templify.DocumentGenerator/Program.cs
+++ b/TriasDev.Templify.DocumentGenerator/Program.cs
@@ -42,6 +42,7 @@
     new HelloWorldGenerator(),
     new InvoiceGenerator(),
     new ConditionalGenerator(),
+    new WarningReportTemplateGenerator(),
 };
 
 // Parse command line arguments
diff --git a/TriasDev.Templify.Gui/ViewModels/MainWindowViewModel.cs b/TriasDev.Templify.Gui/ViewModels/MainWindowViewModel.cs
index 32ef7d6..82693d7 100644
--- a/TriasDev.Templify.Gui/ViewModels/MainWindowViewModel.cs
+++ b/TriasDev.Templify.Gui/ViewModels/MainWindowViewModel.cs
@@ -56,6 +56,13 @@ public partial class MainWindowViewModel : ViewModelBase
     [ObservableProperty]
     private bool _enableHtmlEntityReplacement;
 
+    /// <summary>
+    /// Stores the last processing result to enable warning report generation.
+    /// </summary>
+    [ObservableProperty]
+    [NotifyCanExecuteChangedFor(nameof(GenerateWarningReportCommand))]
+    private UiProcessingResult? _lastProcessingResult;
+
     public MainWindowViewModel(
         ITemplifyService templifyService,
         IFileDialogService fileDialogService)
@@ -191,23 +198,27 @@ private async Task ProcessTemplateAsync()
                 EnableHtmlEntityReplacement,
                 progressReporter);
 
+            // Store for warning report generation
+            LastProcessingResult = result;
+
             if (result.Success)
             {
                 Results.Add("✓ Template processed successfully!");
                 Results.Add($"✓ Made {result.Processing.ReplacementCount} replacements");
                 Results.Add($"✓ Output saved to: {result.OutputPath}");
 
-                if (result.Validation.MissingVariables.Count > 0)
+                if (result.Processing.HasWarnings)
                 {
-                    Results.Add($"⚠ {result.Validation.MissingVariables.Count} missing variables:");
-                    foreach (string missing in result.Validation.MissingVariables.Take(5))
+                    Results.Add($"⚠ {result.Processing.Warnings.Count} processing warnings:");
+                    foreach (ProcessingWarning warning in result.Processing.Warnings.Take(5))
                     {
-                        Results.Add($"  - {missing}");
+                        Results.Add($"  - {warning.Type}: {warning.VariableName}");
                     }
-                    if (result.Validation.MissingVariables.Count > 5)
+                    if (result.Processing.Warnings.Count > 5)
                     {
-                        Results.Add($"  ... and {result.Validation.MissingVariables.Count - 5} more");
+                        Results.Add($"  ... and {result.Processing.Warnings.Count - 5} more");
                     }
+                    Results.Add("  (Use 'Generate Warning Report' for full details)");
                 }
 
                 StatusMessage = "Processing complete";
@@ -269,8 +280,59 @@ private void Clear()
         Results.Clear();
         StatusMessage = "Ready";
         Progress = 0;
+        LastProcessingResult = null;
     }
 
+    [RelayCommand(CanExecute = nameof(CanGenerateWarningReport))]
+    private async Task GenerateWarningReportAsync()
+    {
+        if (LastProcessingResult == null || !LastProcessingResult.Processing.HasWarnings)
+        {
+            return;
+        }
+
+        try
+        {
+            // Generate default filename based on template name
+            string defaultName = "warning-report.docx";
+            if (!string.IsNullOrEmpty(TemplatePath))
+            {
+                string templateName = Path.GetFileNameWithoutExtension(TemplatePath);
+                defaultName = $"{templateName}-warnings.docx";
+            }
+
+            // Ask user where to save
+            string? savePath = await _fileDialogService.SaveOutputFileAsync(defaultName);
+            if (string.IsNullOrEmpty(savePath))
+            {
+                return; // User cancelled
+            }
+
+            // Generate and save the report
+            byte[] reportBytes = LastProcessingResult.Processing.GetWarningReportBytes();
+            await File.WriteAllBytesAsync(savePath, reportBytes);
+
+            Results.Add($"✓ Warning report saved to: {savePath}");
+            StatusMessage = "Warning report generated";
+
+            // Offer to open the report
+            Process.Start(new ProcessStartInfo
+            {
+                FileName = savePath,
+                UseShellExecute = true
+            });
+        }
+        catch (Exception ex)
+        {
+            Results.Add($"✗ Failed to generate warning report: {ex.Message}");
+        }
+    }
+
+    private bool CanGenerateWarningReport() =>
+        LastProcessingResult != null &&
+        LastProcessingResult.Success &&
+        LastProcessingResult.Processing.HasWarnings;
+
     private void UpdateOutputPath()
     {
         if (string.IsNullOrEmpty(TemplatePath))
diff --git a/TriasDev.Templify.Gui/Views/MainWindow.axaml b/TriasDev.Templify.Gui/Views/MainWindow.axaml
index a2a7baa..93972aa 100644
--- a/TriasDev.Templify.Gui/Views/MainWindow.axaml
+++ b/TriasDev.Templify.Gui/Views/MainWindow.axaml
@@ -112,6 +112,10 @@
 
         <!-- Bottom Action Buttons -->
         <StackPanel Grid.Row="8" Orientation="Horizontal" Spacing="10" HorizontalAlignment="Right">
+            <Button Content="Generate Warning Report"
+                    Command="{Binding GenerateWarningReportCommand}"
+                    ToolTip.Tip="Generate a Word document containing all processing warnings"
+                    Width="170"/>
             <Button Content="Open Output File"
                     Command="{Binding OpenOutputFileCommand}"
                     Width="130"/>
diff --git a/TriasDev.Templify.Tests/Integration/ProcessingWarningsIntegrationTests.cs b/TriasDev.Templify.Tests/Integration/ProcessingWarningsIntegrationTests.cs
new file mode 100644
index 0000000..4bbc6aa
--- /dev/null
+++ b/TriasDev.Templify.Tests/Integration/ProcessingWarningsIntegrationTests.cs
@@ -0,0 +1,402 @@
+// Copyright (c) 2026 TriasDev GmbH & Co. KG
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Wordprocessing;
+using TriasDev.Templify.Core;
+using TriasDev.Templify.Tests.Helpers;
+
+namespace TriasDev.Templify.Tests.Integration;
+
+/// <summary>
+/// Integration tests for processing warnings feature.
+/// Tests that warnings are collected during template processing for missing variables,
+/// null/missing loop collections, etc.
+/// </summary>
+public sealed class ProcessingWarningsIntegrationTests
+{
+    [Fact]
+    public void ProcessTemplate_MissingVariable_CollectsWarning()
+    {
+        // Arrange
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("Hello {{MissingName}}!");
+
+        Dictionary<string, object> data = new Dictionary<string, object>();
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.True(result.HasWarnings);
+        Assert.Single(result.Warnings);
+
+        ProcessingWarning warning = result.Warnings[0];
+        Assert.Equal(ProcessingWarningType.MissingVariable, warning.Type);
+        Assert.Equal("MissingName", warning.VariableName);
+        Assert.Contains("MissingName", warning.Message);
+    }
+
+    [Fact]
+    public void ProcessTemplate_MultipleMissingVariables_CollectsAllWarnings()
+    {
+        // Arrange
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("{{Missing1}} and {{Missing2}} and {{Missing3}}");
+
+        Dictionary<string, object> data = new Dictionary<string, object>();
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.Equal(3, result.Warnings.Count);
+        Assert.All(result.Warnings, w => Assert.Equal(ProcessingWarningType.MissingVariable, w.Type));
+    }
+
+    [Fact]
+    public void ProcessTemplate_MissingLoopCollection_CollectsWarning()
+    {
+        // Arrange
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("{{#foreach MissingItems}}");
+        builder.AddParagraph("Item: {{.}}");
+        builder.AddParagraph("{{/foreach}}");
+
+        Dictionary<string, object> data = new Dictionary<string, object>();
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.True(result.HasWarnings);
+        Assert.Single(result.Warnings);
+
+        ProcessingWarning warning = result.Warnings[0];
+        Assert.Equal(ProcessingWarningType.MissingLoopCollection, warning.Type);
+        Assert.Equal("MissingItems", warning.VariableName);
+        Assert.Contains("loop: MissingItems", warning.Context);
+    }
+
+    [Fact]
+    public void ProcessTemplate_NullLoopCollection_CollectsWarning()
+    {
+        // Arrange
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("{{#foreach NullItems}}");
+        builder.AddParagraph("Item: {{.}}");
+        builder.AddParagraph("{{/foreach}}");
+
+        Dictionary<string, object?> data = new Dictionary<string, object?>
+        {
+            ["NullItems"] = null
+        };
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data!);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.True(result.HasWarnings);
+        Assert.Single(result.Warnings);
+
+        ProcessingWarning warning = result.Warnings[0];
+        Assert.Equal(ProcessingWarningType.NullLoopCollection, warning.Type);
+        Assert.Equal("NullItems", warning.VariableName);
+        Assert.Contains("null", warning.Message.ToLowerInvariant());
+    }
+
+    [Fact]
+    public void ProcessTemplate_EmptyCollection_NoWarning()
+    {
+        // Arrange - empty collection should NOT produce a warning (by design)
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("{{#foreach EmptyItems}}");
+        builder.AddParagraph("Item: {{.}}");
+        builder.AddParagraph("{{/foreach}}");
+
+        Dictionary<string, object> data = new Dictionary<string, object>
+        {
+            ["EmptyItems"] = new List<string>() // Empty, but valid
+        };
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.False(result.HasWarnings);
+        Assert.Empty(result.Warnings);
+    }
+
+    [Fact]
+    public void ProcessTemplate_ValidData_NoWarnings()
+    {
+        // Arrange
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("Hello {{Name}}!");
+        builder.AddParagraph("{{#foreach Items}}");
+        builder.AddParagraph("Item: {{.}}");
+        builder.AddParagraph("{{/foreach}}");
+
+        Dictionary<string, object> data = new Dictionary<string, object>
+        {
+            ["Name"] = "World",
+            ["Items"] = new List<string> { "A", "B", "C" }
+        };
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.False(result.HasWarnings);
+        Assert.Empty(result.Warnings);
+    }
+
+    [Fact]
+    public void ProcessTemplate_MixedWarnings_CollectsAll()
+    {
+        // Arrange - multiple warning types in one template
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("Hello {{MissingName}}!");
+        builder.AddParagraph("{{#foreach MissingItems}}");
+        builder.AddParagraph("Item: {{.}}");
+        builder.AddParagraph("{{/foreach}}");
+        builder.AddParagraph("{{#foreach NullItems}}");
+        builder.AddParagraph("Item: {{.}}");
+        builder.AddParagraph("{{/foreach}}");
+
+        Dictionary<string, object?> data = new Dictionary<string, object?>
+        {
+            ["NullItems"] = null
+        };
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data!);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.True(result.HasWarnings);
+        Assert.Equal(3, result.Warnings.Count);
+
+        // Verify we have different warning types
+        Assert.Contains(result.Warnings, w => w.Type == ProcessingWarningType.MissingVariable);
+        Assert.Contains(result.Warnings, w => w.Type == ProcessingWarningType.MissingLoopCollection);
+        Assert.Contains(result.Warnings, w => w.Type == ProcessingWarningType.NullLoopCollection);
+    }
+
+    [Fact]
+    public void ProcessingWarning_ToString_ContainsUsefulInfo()
+    {
+        // Arrange
+        ProcessingWarning warning = ProcessingWarning.MissingVariable("TestVar");
+
+        // Act
+        string str = warning.ToString();
+
+        // Assert
+        Assert.Contains("MissingVariable", str);
+        Assert.Contains("TestVar", str);
+    }
+
+    [Fact]
+    public void ProcessTemplate_NestedMissingVariable_CollectsWarning()
+    {
+        // Arrange - missing nested path like Customer.Name
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("{{Customer.Name}}");
+
+        Dictionary<string, object> data = new Dictionary<string, object>();
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.True(result.HasWarnings);
+        Assert.Single(result.Warnings);
+        Assert.Equal("Customer.Name", result.Warnings[0].VariableName);
+    }
+
+    #region Warning Report Tests
+
+    [Fact]
+    public void GetWarningReport_WithWarnings_ReturnsValidDocx()
+    {
+        // Arrange - create a result with warnings
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("Hello {{MissingName}}!");
+        builder.AddParagraph("{{#foreach MissingItems}}");
+        builder.AddParagraph("Item: {{.}}");
+        builder.AddParagraph("{{/foreach}}");
+
+        Dictionary<string, object> data = new Dictionary<string, object>();
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Act
+        using MemoryStream reportStream = result.GetWarningReport();
+
+        // Assert - verify it's a valid docx
+        Assert.True(reportStream.Length > 0);
+        reportStream.Position = 0;
+
+        using WordprocessingDocument doc = WordprocessingDocument.Open(reportStream, false);
+        Body? body = doc.MainDocumentPart?.Document.Body;
+        Assert.NotNull(body);
+
+        string text = body.InnerText;
+        Assert.Contains("Warning Report", text);
+        Assert.Contains("2", text); // Total 2 warnings
+    }
+
+    [Fact]
+    public void GetWarningReport_NoWarnings_ReturnsEmptyReport()
+    {
+        // Arrange - create a result with no warnings
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("Hello {{Name}}!");
+
+        Dictionary<string, object> data = new Dictionary<string, object>
+        {
+            ["Name"] = "World"
+        };
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Act
+        using MemoryStream reportStream = result.GetWarningReport();
+
+        // Assert - verify it's a valid docx with 0 warnings
+        Assert.True(reportStream.Length > 0);
+        reportStream.Position = 0;
+
+        using WordprocessingDocument doc = WordprocessingDocument.Open(reportStream, false);
+        Body? body = doc.MainDocumentPart?.Document.Body;
+        Assert.NotNull(body);
+
+        string text = body.InnerText;
+        Assert.Contains("Warning Report", text);
+        Assert.Contains("Total Warnings: 0", text);
+    }
+
+    [Fact]
+    public void GetWarningReportBytes_WithWarnings_ReturnsByteArray()
+    {
+        // Arrange
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("Hello {{MissingVar}}!");
+
+        Dictionary<string, object> data = new Dictionary<string, object>();
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Act
+        byte[] reportBytes = result.GetWarningReportBytes();
+
+        // Assert
+        Assert.True(reportBytes.Length > 0);
+
+        // Verify it's a valid docx by loading it
+        using MemoryStream stream = new MemoryStream(reportBytes);
+        using WordprocessingDocument doc = WordprocessingDocument.Open(stream, false);
+        Assert.NotNull(doc.MainDocumentPart?.Document.Body);
+    }
+
+    [Fact]
+    public void GetWarningReport_MixedWarnings_ContainsAllSections()
+    {
+        // Arrange - create warnings of all types
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("{{MissingVar1}}");
+        builder.AddParagraph("{{MissingVar2}}");
+        builder.AddParagraph("{{#foreach MissingCollection}}{{.}}{{/foreach}}");
+        builder.AddParagraph("{{#foreach NullCollection}}{{.}}{{/foreach}}");
+
+        Dictionary<string, object?> data = new Dictionary<string, object?>
+        {
+            ["NullCollection"] = null
+        };
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data!);
+
+        // Act
+        using MemoryStream reportStream = result.GetWarningReport();
+
+        // Assert
+        reportStream.Position = 0;
+        using WordprocessingDocument doc = WordprocessingDocument.Open(reportStream, false);
+        Body? body = doc.MainDocumentPart?.Document.Body;
+        Assert.NotNull(body);
+
+        string text = body.InnerText;
+
+        // Should contain all sections
+        Assert.Contains("Missing Variables", text);
+        Assert.Contains("Missing Loop Collections", text);
+        Assert.Contains("Null Loop Collections", text);
+
+        // Should contain the specific variable names
+        Assert.Contains("MissingVar1", text);
+        Assert.Contains("MissingVar2", text);
+        Assert.Contains("MissingCollection", text);
+        Assert.Contains("NullCollection", text);
+
+        // Should have correct counts
+        Assert.Contains("Total Warnings: 4", text);
+    }
+
+    #endregion
+}
diff --git a/TriasDev.Templify.Tests/Visitors/CompositeVisitorTests.cs b/TriasDev.Templify.Tests/Visitors/CompositeVisitorTests.cs
index 586c0d3..df9f7ca 100644
--- a/TriasDev.Templify.Tests/Visitors/CompositeVisitorTests.cs
+++ b/TriasDev.Templify.Tests/Visitors/CompositeVisitorTests.cs
@@ -233,7 +233,7 @@ public void CompositeVisitor_WithRealVisitors_WorksTogether()
             isTableRowConditional: false,
             nestingLevel: 0);
 
-        ConditionalVisitor conditionalVisitor = new ConditionalVisitor();
+        ConditionalVisitor conditionalVisitor = new ConditionalVisitor(new WarningCollector());
         MockVisitor mockVisitor = new MockVisitor();
 
         CompositeVisitor composite = new CompositeVisitor(conditionalVisitor, mockVisitor);
diff --git a/TriasDev.Templify.Tests/Visitors/ConditionalVisitorTests.cs b/TriasDev.Templify.Tests/Visitors/ConditionalVisitorTests.cs
index d5bc0e4..1d1e9d1 100644
--- a/TriasDev.Templify.Tests/Visitors/ConditionalVisitorTests.cs
+++ b/TriasDev.Templify.Tests/Visitors/ConditionalVisitorTests.cs
@@ -41,7 +41,7 @@ public void VisitConditional_TrueCondition_KeepsIfBranchRemovesElse()
             isTableRowConditional: false,
             nestingLevel: 0);
 
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
         Dictionary<string, object> data = new Dictionary<string, object> { ["IsActive"] = true };
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
 
@@ -83,7 +83,7 @@ public void VisitConditional_FalseCondition_KeepsElseBranchRemovesIf()
             isTableRowConditional: false,
             nestingLevel: 0);
 
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
         Dictionary<string, object> data = new Dictionary<string, object> { ["IsActive"] = false };
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
 
@@ -123,7 +123,7 @@ public void VisitConditional_NoElseBranch_TrueCondition_KeepsIfContent()
             isTableRowConditional: false,
             nestingLevel: 0);
 
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
         Dictionary<string, object> data = new Dictionary<string, object> { ["IsActive"] = true };
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
 
@@ -157,7 +157,7 @@ public void VisitConditional_NoElseBranch_FalseCondition_RemovesAllContent()
             isTableRowConditional: false,
             nestingLevel: 0);
 
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
         Dictionary<string, object> data = new Dictionary<string, object> { ["IsActive"] = false };
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
 
@@ -191,7 +191,7 @@ public void VisitConditional_ComparisonOperator_EvaluatesCorrectly()
             isTableRowConditional: false,
             nestingLevel: 0);
 
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
         Dictionary<string, object> data = new Dictionary<string, object> { ["Count"] = 10 };
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
 
@@ -227,7 +227,7 @@ public void VisitConditional_LoopMetadata_EvaluatesWithLoopContext()
             isTableRowConditional: false,
             nestingLevel: 0);
 
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
 
         // Create loop context (simulating first item in loop)
         LoopContext loopContext = new LoopContext("Item1", 0, 3, "Items");
@@ -267,7 +267,7 @@ public void VisitConditional_MultipleIfContentElements_RemovesAll()
             isTableRowConditional: false,
             nestingLevel: 0);
 
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
         Dictionary<string, object> data = new Dictionary<string, object> { ["False"] = false };
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
 
@@ -282,7 +282,7 @@ public void VisitConditional_MultipleIfContentElements_RemovesAll()
     public void VisitLoop_DoesNothing()
     {
         // Arrange
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
         LoopBlock loop = CreateTestLoopBlock();
         GlobalEvaluationContext context = new GlobalEvaluationContext(new Dictionary<string, object>());
 
@@ -297,7 +297,7 @@ public void VisitLoop_DoesNothing()
     public void VisitPlaceholder_DoesNothing()
     {
         // Arrange
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
         PlaceholderMatch placeholder = new PlaceholderMatch
         {
             VariableName = "Name",
@@ -319,7 +319,7 @@ public void VisitPlaceholder_DoesNothing()
     public void VisitParagraph_DoesNothing()
     {
         // Arrange
-        ConditionalVisitor visitor = new ConditionalVisitor();
+        ConditionalVisitor visitor = new ConditionalVisitor(new WarningCollector());
         Paragraph paragraph = new Paragraph(new Run(new Text("Regular text")));
         GlobalEvaluationContext context = new GlobalEvaluationContext(new Dictionary<string, object>());
 
diff --git a/TriasDev.Templify.Tests/Visitors/LoopVisitorTests.cs b/TriasDev.Templify.Tests/Visitors/LoopVisitorTests.cs
index 5c99072..f095441 100644
--- a/TriasDev.Templify.Tests/Visitors/LoopVisitorTests.cs
+++ b/TriasDev.Templify.Tests/Visitors/LoopVisitorTests.cs
@@ -40,7 +40,7 @@ public void VisitLoop_EmptyCollection_RemovesLoopBlock()
 
         DocumentWalker walker = new DocumentWalker();
         MockVisitor nestedVisitor = new MockVisitor();
-        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor);
+        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>
         {
@@ -77,7 +77,7 @@ public void VisitLoop_MissingCollection_RemovesLoopBlock()
 
         DocumentWalker walker = new DocumentWalker();
         MockVisitor nestedVisitor = new MockVisitor();
-        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor);
+        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>();
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
@@ -89,6 +89,43 @@ public void VisitLoop_MissingCollection_RemovesLoopBlock()
         Assert.Empty(body.Elements<Paragraph>());
     }
 
+    [Fact]
+    public void VisitLoop_NullCollection_RemovesLoopBlock()
+    {
+        // Arrange
+        Body body = new Body();
+        Paragraph startMarker = new Paragraph(new Run(new Text("{{#foreach Items}}")));
+        Paragraph content = new Paragraph(new Run(new Text("Item: {{.}}")));
+        Paragraph endMarker = new Paragraph(new Run(new Text("{{/foreach}}")));
+
+        body.Append(startMarker, content, endMarker);
+
+        LoopBlock loop = new LoopBlock(
+            collectionName: "Items",
+            iterationVariableName: null,
+            contentElements: new List<OpenXmlElement> { content },
+            startMarker: startMarker,
+            endMarker: endMarker,
+            isTableRowLoop: false,
+            emptyBlock: null);
+
+        DocumentWalker walker = new DocumentWalker();
+        MockVisitor nestedVisitor = new MockVisitor();
+        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor, new WarningCollector());
+
+        Dictionary<string, object?> data = new Dictionary<string, object?>
+        {
+            ["Items"] = null // Null collection - should be treated same as missing
+        };
+        GlobalEvaluationContext context = new GlobalEvaluationContext(data!);
+
+        // Act
+        visitor.VisitLoop(loop, context);
+
+        // Assert - all content removed (same behavior as missing collection)
+        Assert.Empty(body.Elements<Paragraph>());
+    }
+
     [Fact]
     public void VisitLoop_NonCollectionVariable_ThrowsInvalidOperationException()
     {
@@ -111,7 +148,7 @@ public void VisitLoop_NonCollectionVariable_ThrowsInvalidOperationException()
 
         DocumentWalker walker = new DocumentWalker();
         MockVisitor nestedVisitor = new MockVisitor();
-        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor);
+        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>
         {
@@ -149,7 +186,7 @@ public void VisitLoop_SimpleCollection_ExpandsLoopContent()
 
         DocumentWalker walker = new DocumentWalker();
         MockVisitor nestedVisitor = new MockVisitor();
-        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor);
+        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>
         {
@@ -189,7 +226,7 @@ public void VisitLoop_MultipleContentElements_ClonesAll()
 
         DocumentWalker walker = new DocumentWalker();
         MockVisitor nestedVisitor = new MockVisitor();
-        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor);
+        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>
         {
@@ -235,7 +272,7 @@ public void VisitLoop_CreatesLoopEvaluationContext()
 
         DocumentWalker walker = new DocumentWalker();
         ContextCapturingVisitor nestedVisitor = new ContextCapturingVisitor();
-        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor);
+        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>
         {
@@ -273,7 +310,7 @@ public void VisitLoop_ProcessesNestedConstructsViaDocumentWalker()
 
         DocumentWalker walker = new DocumentWalker();
         MockVisitor nestedVisitor = new MockVisitor();
-        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor);
+        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>
         {
@@ -313,7 +350,7 @@ public void VisitLoop_SingleItem_CreatesOneIteration()
 
         DocumentWalker walker = new DocumentWalker();
         MockVisitor nestedVisitor = new MockVisitor();
-        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor);
+        LoopVisitor visitor = new LoopVisitor(walker, nestedVisitor, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>
         {
@@ -334,7 +371,7 @@ public void VisitLoop_SingleItem_CreatesOneIteration()
     public void VisitConditional_DoesNothing()
     {
         // Arrange
-        LoopVisitor visitor = new LoopVisitor(new DocumentWalker(), new MockVisitor());
+        LoopVisitor visitor = new LoopVisitor(new DocumentWalker(), new MockVisitor(), new WarningCollector());
         ConditionalBlock conditional = CreateTestConditionalBlock();
         GlobalEvaluationContext context = new GlobalEvaluationContext(new Dictionary<string, object>());
 
@@ -349,7 +386,7 @@ public void VisitConditional_DoesNothing()
     public void VisitPlaceholder_DoesNothing()
     {
         // Arrange
-        LoopVisitor visitor = new LoopVisitor(new DocumentWalker(), new MockVisitor());
+        LoopVisitor visitor = new LoopVisitor(new DocumentWalker(), new MockVisitor(), new WarningCollector());
         PlaceholderMatch placeholder = new PlaceholderMatch
         {
             VariableName = "Name",
@@ -371,7 +408,7 @@ public void VisitPlaceholder_DoesNothing()
     public void VisitParagraph_DoesNothing()
     {
         // Arrange
-        LoopVisitor visitor = new LoopVisitor(new DocumentWalker(), new MockVisitor());
+        LoopVisitor visitor = new LoopVisitor(new DocumentWalker(), new MockVisitor(), new WarningCollector());
         Paragraph paragraph = new Paragraph(new Run(new Text("Regular text")));
         GlobalEvaluationContext context = new GlobalEvaluationContext(new Dictionary<string, object>());
 
diff --git a/TriasDev.Templify.Tests/Visitors/PlaceholderVisitorTests.cs b/TriasDev.Templify.Tests/Visitors/PlaceholderVisitorTests.cs
index a839b6c..808ec51 100644
--- a/TriasDev.Templify.Tests/Visitors/PlaceholderVisitorTests.cs
+++ b/TriasDev.Templify.Tests/Visitors/PlaceholderVisitorTests.cs
@@ -31,7 +31,7 @@ public void VisitPlaceholder_VariableFound_ReplacesPlaceholder()
 
         PlaceholderReplacementOptions options = new PlaceholderReplacementOptions();
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>
         {
@@ -65,7 +65,7 @@ public void VisitPlaceholder_VariableNotFound_LeaveUnchanged()
             MissingVariableBehavior = MissingVariableBehavior.LeaveUnchanged
         };
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>();
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
@@ -96,7 +96,7 @@ public void VisitPlaceholder_VariableNotFound_ReplaceWithEmpty()
             MissingVariableBehavior = MissingVariableBehavior.ReplaceWithEmpty
         };
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>();
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
@@ -127,7 +127,7 @@ public void VisitPlaceholder_VariableNotFound_ThrowException()
             MissingVariableBehavior = MissingVariableBehavior.ThrowException
         };
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>();
         GlobalEvaluationContext context = new GlobalEvaluationContext(data);
@@ -155,7 +155,7 @@ public void VisitPlaceholder_NumericValue_ConvertsToString()
 
         PlaceholderReplacementOptions options = new PlaceholderReplacementOptions();
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         Dictionary<string, object> data = new Dictionary<string, object>
         {
@@ -185,7 +185,7 @@ public void VisitPlaceholder_DateValue_ConvertsToString()
 
         PlaceholderReplacementOptions options = new PlaceholderReplacementOptions();
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         DateTime testDate = new DateTime(2025, 11, 9);
         Dictionary<string, object> data = new Dictionary<string, object>
@@ -222,7 +222,7 @@ public void VisitPlaceholder_LoopContext_ResolvesLoopVariable()
 
         PlaceholderReplacementOptions options = new PlaceholderReplacementOptions();
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         // Create loop context
         LoopContext loopContext = new LoopContext("TestItem", 0, 1, "Items");
@@ -252,7 +252,7 @@ public void VisitPlaceholder_LoopMetadata_ResolvesMetadataVariable()
 
         PlaceholderReplacementOptions options = new PlaceholderReplacementOptions();
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         // Create loop context (index 2 of 5)
         LoopContext loopContext = new LoopContext("Item", 2, 5, "Items");
@@ -273,7 +273,7 @@ public void VisitConditional_DoesNothing()
         // Arrange
         PlaceholderReplacementOptions options = new PlaceholderReplacementOptions();
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         ConditionalBlock conditional = CreateTestConditionalBlock();
         GlobalEvaluationContext context = new GlobalEvaluationContext(new Dictionary<string, object>());
@@ -291,7 +291,7 @@ public void VisitLoop_DoesNothing()
         // Arrange
         PlaceholderReplacementOptions options = new PlaceholderReplacementOptions();
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         LoopBlock loop = CreateTestLoopBlock();
         GlobalEvaluationContext context = new GlobalEvaluationContext(new Dictionary<string, object>());
@@ -309,7 +309,7 @@ public void VisitParagraph_DoesNothing()
         // Arrange
         PlaceholderReplacementOptions options = new PlaceholderReplacementOptions();
         HashSet<string> missingVariables = new HashSet<string>();
-        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables);
+        PlaceholderVisitor visitor = new PlaceholderVisitor(options, missingVariables, new WarningCollector());
 
         Paragraph paragraph = new Paragraph(new Run(new Text("Regular text")));
         GlobalEvaluationContext context = new GlobalEvaluationContext(new Dictionary<string, object>());
diff --git a/TriasDev.Templify/Core/DocumentTemplateProcessor.cs b/TriasDev.Templify/Core/DocumentTemplateProcessor.cs
index 067f096..8157ca3 100644
--- a/TriasDev.Templify/Core/DocumentTemplateProcessor.cs
+++ b/TriasDev.Templify/Core/DocumentTemplateProcessor.cs
@@ -78,11 +78,12 @@ public ProcessingResult ProcessTemplate(
             CopyStream(templateStream, outputStream);
             outputStream.Position = 0;
 
-            // Track missing variables
+            // Track missing variables and warnings
             HashSet<string> missingVariables = new HashSet<string>();
+            WarningCollector warningCollector = new WarningCollector();
 
             // Create placeholder visitor to track replacements
-            PlaceholderVisitor placeholderVisitor = new PlaceholderVisitor(_options, missingVariables);
+            PlaceholderVisitor placeholderVisitor = new PlaceholderVisitor(_options, missingVariables, warningCollector);
 
             // Open document for editing
             using (WordprocessingDocument document = WordprocessingDocument.Open(outputStream, isEditable: true))
@@ -97,7 +98,7 @@ public ProcessingResult ProcessTemplate(
 
                 // Create visitor instances
                 DocumentWalker walker = new DocumentWalker();
-                ConditionalVisitor conditionalVisitor = new ConditionalVisitor();
+                ConditionalVisitor conditionalVisitor = new ConditionalVisitor(warningCollector);
 
                 // Create a temporary composite for initial loop visitor creation
                 CompositeVisitor tempComposite = new CompositeVisitor(
@@ -106,7 +107,7 @@ public ProcessingResult ProcessTemplate(
                 );
 
                 // Create loop visitor with temporary composite
-                LoopVisitor loopVisitor = new LoopVisitor(walker, tempComposite);
+                LoopVisitor loopVisitor = new LoopVisitor(walker, tempComposite, warningCollector);
 
                 // Create the final composite that includes all visitors (including loop)
                 CompositeVisitor composite = new CompositeVisitor(
@@ -139,10 +140,11 @@ public ProcessingResult ProcessTemplate(
                 document.MainDocumentPart.Document.Save();
             }
 
-            // Return success with replacement count from placeholder visitor
+            // Return success with replacement count and warnings
             return ProcessingResult.Success(
                 replacementCount: placeholderVisitor.ReplacementCount,
-                missingVariables: missingVariables.OrderBy(v => v).ToList());
+                missingVariables: missingVariables.OrderBy(v => v).ToList(),
+                warnings: warningCollector.GetWarnings());
         }
         catch (InvalidOperationException)
         {
diff --git a/TriasDev.Templify/Core/IWarningCollector.cs b/TriasDev.Templify/Core/IWarningCollector.cs
new file mode 100644
index 0000000..1e3645c
--- /dev/null
+++ b/TriasDev.Templify/Core/IWarningCollector.cs
@@ -0,0 +1,43 @@
+// Copyright (c) 2026 TriasDev GmbH & Co. KG
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+
+namespace TriasDev.Templify.Core;
+
+/// <summary>
+/// Interface for collecting warnings during template processing.
+/// </summary>
+internal interface IWarningCollector
+{
+    /// <summary>
+    /// Adds a warning to the collection.
+    /// </summary>
+    /// <param name="warning">The warning to add.</param>
+    void AddWarning(ProcessingWarning warning);
+
+    /// <summary>
+    /// Gets all collected warnings.
+    /// </summary>
+    /// <returns>A read-only list of warnings.</returns>
+    IReadOnlyList<ProcessingWarning> GetWarnings();
+}
+
+/// <summary>
+/// Default implementation of <see cref="IWarningCollector"/> that collects warnings in a list.
+/// </summary>
+internal sealed class WarningCollector : IWarningCollector
+{
+    private readonly List<ProcessingWarning> _warnings = new();
+
+    /// <inheritdoc/>
+    public void AddWarning(ProcessingWarning warning)
+    {
+        ArgumentNullException.ThrowIfNull(warning);
+        _warnings.Add(warning);
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<ProcessingWarning> GetWarnings()
+    {
+        return _warnings.AsReadOnly();
+    }
+}
diff --git a/TriasDev.Templify/Core/ProcessingResult.cs b/TriasDev.Templify/Core/ProcessingResult.cs
index 1c5510d..08ab51a 100644
--- a/TriasDev.Templify/Core/ProcessingResult.cs
+++ b/TriasDev.Templify/Core/ProcessingResult.cs
@@ -29,16 +29,60 @@ public sealed class ProcessingResult
     /// </summary>
     public IReadOnlyList<string> MissingVariables { get; init; } = Array.Empty<string>();
 
+    /// <summary>
+    /// Gets a read-only list of warnings that occurred during processing.
+    /// Warnings are non-fatal issues such as missing variables, null collections, or failed expressions.
+    /// </summary>
+    public IReadOnlyList<ProcessingWarning> Warnings { get; init; } = Array.Empty<ProcessingWarning>();
+
+    /// <summary>
+    /// Gets whether any warnings were generated during processing.
+    /// </summary>
+    public bool HasWarnings => Warnings.Count > 0;
+
+    /// <summary>
+    /// Generates a Word document report containing all processing warnings.
+    /// The report is formatted using Templify itself with an embedded template.
+    /// </summary>
+    /// <returns>A MemoryStream containing the .docx warning report. The caller is responsible for disposing the stream.</returns>
+    /// <remarks>
+    /// If there are no warnings, the report will still be generated but will show "0 warnings".
+    /// The returned stream is positioned at the beginning and ready to be read or saved.
+    /// </remarks>
+    public MemoryStream GetWarningReport()
+    {
+        return WarningReportGenerator.GenerateReport(Warnings);
+    }
+
+    /// <summary>
+    /// Generates a Word document report containing all processing warnings and returns it as a byte array.
+    /// The report is formatted using Templify itself with an embedded template.
+    /// </summary>
+    /// <returns>A byte array containing the .docx warning report.</returns>
+    /// <remarks>
+    /// If there are no warnings, the report will still be generated but will show "0 warnings".
+    /// This method is a convenience wrapper around <see cref="GetWarningReport"/> for scenarios
+    /// where a byte array is more convenient than a stream.
+    /// </remarks>
+    public byte[] GetWarningReportBytes()
+    {
+        return WarningReportGenerator.GenerateReportBytes(Warnings);
+    }
+
     /// <summary>
     /// Creates a successful processing result.
     /// </summary>
-    public static ProcessingResult Success(int replacementCount, IReadOnlyList<string>? missingVariables = null)
+    public static ProcessingResult Success(
+        int replacementCount,
+        IReadOnlyList<string>? missingVariables = null,
+        IReadOnlyList<ProcessingWarning>? warnings = null)
     {
         return new ProcessingResult
         {
             IsSuccess = true,
             ReplacementCount = replacementCount,
-            MissingVariables = missingVariables ?? Array.Empty<string>()
+            MissingVariables = missingVariables ?? Array.Empty<string>(),
+            Warnings = warnings ?? Array.Empty<ProcessingWarning>()
         };
     }
 
diff --git a/TriasDev.Templify/Core/ProcessingWarning.cs b/TriasDev.Templify/Core/ProcessingWarning.cs
new file mode 100644
index 0000000..0853091
--- /dev/null
+++ b/TriasDev.Templify/Core/ProcessingWarning.cs
@@ -0,0 +1,127 @@
+// Copyright (c) 2026 TriasDev GmbH & Co. KG
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+
+namespace TriasDev.Templify.Core;
+
+/// <summary>
+/// Represents a warning that occurred during template processing.
+/// Warnings are non-fatal issues that don't prevent processing but may indicate problems with the template or data.
+/// </summary>
+public sealed class ProcessingWarning
+{
+    /// <summary>
+    /// Gets the type of warning.
+    /// </summary>
+    public ProcessingWarningType Type { get; }
+
+    /// <summary>
+    /// Gets a human-readable message describing the warning.
+    /// </summary>
+    public string Message { get; }
+
+    /// <summary>
+    /// Gets the name of the variable or collection involved, if applicable.
+    /// </summary>
+    public string? VariableName { get; }
+
+    /// <summary>
+    /// Gets additional context about where the warning occurred (e.g., "loop: Items", "conditional: IsActive").
+    /// </summary>
+    public string? Context { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ProcessingWarning"/> class.
+    /// </summary>
+    /// <param name="type">The type of warning.</param>
+    /// <param name="message">A human-readable message describing the warning.</param>
+    /// <param name="variableName">The name of the variable or collection involved, if applicable.</param>
+    /// <param name="context">Additional context about where the warning occurred.</param>
+    public ProcessingWarning(ProcessingWarningType type, string message, string? variableName = null, string? context = null)
+    {
+        Type = type;
+        Message = message ?? throw new ArgumentNullException(nameof(message));
+        VariableName = variableName;
+        Context = context;
+    }
+
+    /// <summary>
+    /// Creates a warning for a missing variable in a placeholder.
+    /// </summary>
+    public static ProcessingWarning MissingVariable(string variableName)
+    {
+        return new ProcessingWarning(
+            ProcessingWarningType.MissingVariable,
+            $"Variable '{variableName}' was not found in the data.",
+            variableName,
+            "placeholder");
+    }
+
+    /// <summary>
+    /// Creates a warning for a missing loop collection.
+    /// </summary>
+    public static ProcessingWarning MissingLoopCollection(string collectionName)
+    {
+        return new ProcessingWarning(
+            ProcessingWarningType.MissingLoopCollection,
+            $"Loop collection '{collectionName}' was not found in the data.",
+            collectionName,
+            $"loop: {collectionName}");
+    }
+
+    /// <summary>
+    /// Creates a warning for a null loop collection.
+    /// </summary>
+    public static ProcessingWarning NullLoopCollection(string collectionName)
+    {
+        return new ProcessingWarning(
+            ProcessingWarningType.NullLoopCollection,
+            $"Loop collection '{collectionName}' is null.",
+            collectionName,
+            $"loop: {collectionName}");
+    }
+
+    /// <summary>
+    /// Creates a warning for a failed expression evaluation.
+    /// </summary>
+    public static ProcessingWarning ExpressionFailed(string expression, string reason)
+    {
+        return new ProcessingWarning(
+            ProcessingWarningType.ExpressionFailed,
+            $"Expression '{expression}' could not be evaluated: {reason}",
+            expression,
+            "expression");
+    }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        string contextPart = Context != null ? $" [{Context}]" : "";
+        return $"{Type}{contextPart}: {Message}";
+    }
+}
+
+/// <summary>
+/// Defines the types of warnings that can occur during template processing.
+/// </summary>
+public enum ProcessingWarningType
+{
+    /// <summary>
+    /// A placeholder variable was not found in the provided data.
+    /// </summary>
+    MissingVariable,
+
+    /// <summary>
+    /// A loop collection variable was not found in the provided data.
+    /// </summary>
+    MissingLoopCollection,
+
+    /// <summary>
+    /// A loop collection variable was found but its value is null.
+    /// </summary>
+    NullLoopCollection,
+
+    /// <summary>
+    /// An expression (e.g., in a conditional or placeholder) could not be evaluated.
+    /// </summary>
+    ExpressionFailed
+}
diff --git a/TriasDev.Templify/Core/WarningReportGenerator.cs b/TriasDev.Templify/Core/WarningReportGenerator.cs
new file mode 100644
index 0000000..838107c
--- /dev/null
+++ b/TriasDev.Templify/Core/WarningReportGenerator.cs
@@ -0,0 +1,110 @@
+// Copyright (c) 2026 TriasDev GmbH & Co. KG
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+
+using System.Reflection;
+
+namespace TriasDev.Templify.Core;
+
+/// <summary>
+/// Internal generator for creating warning report documents from processing warnings.
+/// Uses an embedded template and Templify itself to render the report.
+/// </summary>
+internal static class WarningReportGenerator
+{
+    private const string TemplateResourceName = "TriasDev.Templify.Resources.WarningReportTemplate.docx";
+
+    /// <summary>
+    /// Generates a warning report document from the provided warnings.
+    /// </summary>
+    /// <param name="warnings">The warnings to include in the report.</param>
+    /// <returns>A MemoryStream containing the generated .docx report.</returns>
+    public static MemoryStream GenerateReport(IReadOnlyList<ProcessingWarning> warnings)
+    {
+        // Load template from embedded resources
+        using Stream templateStream = LoadTemplate();
+
+        // Build data dictionary from warnings
+        Dictionary<string, object> data = BuildReportData(warnings);
+
+        // Process template with Templify
+        MemoryStream outputStream = new MemoryStream();
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Reset position for reading
+        outputStream.Position = 0;
+        return outputStream;
+    }
+
+    /// <summary>
+    /// Generates a warning report document and returns it as a byte array.
+    /// </summary>
+    /// <param name="warnings">The warnings to include in the report.</param>
+    /// <returns>A byte array containing the generated .docx report.</returns>
+    public static byte[] GenerateReportBytes(IReadOnlyList<ProcessingWarning> warnings)
+    {
+        using MemoryStream stream = GenerateReport(warnings);
+        return stream.ToArray();
+    }
+
+    private static Stream LoadTemplate()
+    {
+        Assembly assembly = typeof(WarningReportGenerator).Assembly;
+        Stream? stream = assembly.GetManifestResourceStream(TemplateResourceName);
+
+        if (stream == null)
+        {
+            throw new InvalidOperationException(
+                $"Embedded resource '{TemplateResourceName}' not found. " +
+                "This is a bug in Templify - please report it.");
+        }
+
+        return stream;
+    }
+
+    private static Dictionary<string, object> BuildReportData(IReadOnlyList<ProcessingWarning> warnings)
+    {
+        // Categorize warnings by type
+        List<Dictionary<string, object>> missingVariables = new();
+        List<Dictionary<string, object>> missingCollections = new();
+        List<Dictionary<string, object>> nullCollections = new();
+
+        foreach (ProcessingWarning warning in warnings)
+        {
+            Dictionary<string, object> warningData = new()
+            {
+                ["VariableName"] = warning.VariableName ?? "",
+                ["Context"] = warning.Context ?? "",
+                ["Message"] = warning.Message
+            };
+
+            switch (warning.Type)
+            {
+                case ProcessingWarningType.MissingVariable:
+                    missingVariables.Add(warningData);
+                    break;
+                case ProcessingWarningType.MissingLoopCollection:
+                    missingCollections.Add(warningData);
+                    break;
+                case ProcessingWarningType.NullLoopCollection:
+                    nullCollections.Add(warningData);
+                    break;
+            }
+        }
+
+        return new Dictionary<string, object>
+        {
+            ["GeneratedAt"] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
+            ["TotalWarnings"] = warnings.Count,
+            ["MissingVariableCount"] = missingVariables.Count,
+            ["MissingCollectionCount"] = missingCollections.Count,
+            ["NullCollectionCount"] = nullCollections.Count,
+            ["HasMissingVariables"] = missingVariables.Count > 0,
+            ["HasMissingCollections"] = missingCollections.Count > 0,
+            ["HasNullCollections"] = nullCollections.Count > 0,
+            ["MissingVariables"] = missingVariables,
+            ["MissingCollections"] = missingCollections,
+            ["NullCollections"] = nullCollections
+        };
+    }
+}
diff --git a/TriasDev.Templify/Resources/WarningReportTemplate.docx b/TriasDev.Templify/Resources/WarningReportTemplate.docx
new file mode 100644
index 0000000000000000000000000000000000000000..e7c5ddcac88b660159d08738821e5d338dfe342b
GIT binary patch
literal 1596
zcmWIWW@Zs#U|`^2xX`8^6aVy;Z~_wpLx&IpgCJ0}JijPKKP5l8G&eP`M6V(@=k1KZ
z?Arzc$M<&?%oi_B?nxAyzP9IUqIRnG+s!%ilN*;9U$XQ|`*pW{j)muKm9klDq;>R#
zw!Q!N%iHR|fK;5%)+FH#ev2eo^Vy#>GEYv>I$I$!Wy;>45-~1^wR{XUO(l|o*Y<F)
z4xAt?s`y;*q$9Wa0j4t{t9jOnJz>i@zQ<{{n3!;Z->i*cfA0SL$-b`Dq;YzW;oP75
zKJ@0!n!T)BvcIk7r^iLz7fzf^Wt&5izaNsi|G$Ar_h-Q@b<^C%kri`GYrFO}F=}&M
znsD{&r-#C}HeZ5oJo}Koa_ff8XO*%a-&f+iT2+3}<@2)Ijknp3W?j^6>%E%3MKj{M
zP2#~-1xi;mK5#ElNC<sV*W2{{ppC7Y(v{uGA}L#}51lH!C#cjrSu^G<=dRnLN96q{
zuJ^CKr}npO`P!+sBN?T|W^DJW{i?UoWJ~Oca_g9&FR|ycfA~dcCb8zp2a8<&>a^f&
z{-2yRb8BT|7X?k2;PN@hU%T~iZ0vL|*`$-t-@i|fOOIv<x}I*79Dd05X4BgJdFh5<
zHQUq$PBx~l5DBx(zw~S)myQ9qWP}0d5+5lyOM|SJlGBgy2%X+wa(ewr1;KeMKC`d5
zoTsr{?3c$4Lzc_V2ZFDsOGXKJo~ye0{@ec5U$^aVE_2zhRm~@L^=lF@-yyHq&quXn
zN-xRYd0_N9<w)_qH5cC}9IA2Fu`1ZbZE{kpSU5{0>7idw<=x3=v&{czo+=6b*lAqf
zYuta{L%-dpILz8C@tL}4ecnmeQ$6xYN+F!@N|JucXI@$!=C83bj#>5m;r%nFBwnl4
zKYV+({JveGU3JU>(B#MfPL5?ZmW5i33=AO54NQ*lMX5Q(`g$Pp{qFrX_P_+GP?lO$
zoSC0zt7NEWprnwRmz<xHnU`*>R9cdzYoTOsXA_i~lUM>&QJj%kP^<vdl2>f2lu=Sr
zV5P5LoSc!Gn^>%uUyzyylu64k%1tZ*a*NXS3lfvF6Vp@mjSLLT^no@a%uqr#Qz4|X
zAe9&s^V8BYlT%%wxe1HG`lu?D6hab<(o;)pmGm+4p^}1Uimg(RVVbGAk%fh&S(>S(
zNt%JNl7haSjXsKx?NEdCzBE&K6fihJSQr?j(a!mKCBV!b5AsEEEGUl?AGBaSWCm$6
z#9rMJkiEblbxBQ2EX^rVaIFA32NI(|w<sw<-3JNe#DapH%w%v>=$GZCpv9XmB>dpz
z6)4mSit>|Fi;ICtA~#15E|Z&>nWqgl9vEI&YzCz;(yWFi7f{+nq!hRn`rwcPMg=32
z2s7^D78oC3u%r=0VMIDYJNE1W(agZGq_H1Zh9hMbbdBhV0HN^_Gu9*#;LXYgQp5~|
LJArgAD~JaG#pzdm

literal 0
HcmV?d00001

diff --git a/TriasDev.Templify/TriasDev.Templify.csproj b/TriasDev.Templify/TriasDev.Templify.csproj
index 64d9e20..e5ebbc9 100644
--- a/TriasDev.Templify/TriasDev.Templify.csproj
+++ b/TriasDev.Templify/TriasDev.Templify.csproj
@@ -37,4 +37,8 @@
     <None Include="README.md" Pack="true" PackagePath="\" />
   </ItemGroup>
 
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\WarningReportTemplate.docx" />
+  </ItemGroup>
+
 </Project>
diff --git a/TriasDev.Templify/Visitors/ConditionalVisitor.cs b/TriasDev.Templify/Visitors/ConditionalVisitor.cs
index 8d2a249..485b92f 100644
--- a/TriasDev.Templify/Visitors/ConditionalVisitor.cs
+++ b/TriasDev.Templify/Visitors/ConditionalVisitor.cs
@@ -27,10 +27,12 @@ namespace TriasDev.Templify.Visitors;
 internal sealed class ConditionalVisitor : ITemplateElementVisitor
 {
     private readonly ConditionalEvaluator _evaluator;
+    private readonly IWarningCollector _warningCollector;
 
-    public ConditionalVisitor()
+    public ConditionalVisitor(IWarningCollector warningCollector)
     {
         _evaluator = new ConditionalEvaluator();
+        _warningCollector = warningCollector ?? throw new ArgumentNullException(nameof(warningCollector));
     }
 
     /// <summary>
diff --git a/TriasDev.Templify/Visitors/LoopVisitor.cs b/TriasDev.Templify/Visitors/LoopVisitor.cs
index ab4116e..edbea0f 100644
--- a/TriasDev.Templify/Visitors/LoopVisitor.cs
+++ b/TriasDev.Templify/Visitors/LoopVisitor.cs
@@ -34,13 +34,13 @@ internal sealed class LoopVisitor : ITemplateElementVisitor
 {
     private readonly DocumentWalker _walker;
     private ITemplateElementVisitor _nestedVisitor;
-    private readonly ValueResolver _valueResolver;
+    private readonly IWarningCollector _warningCollector;
 
-    public LoopVisitor(DocumentWalker walker, ITemplateElementVisitor nestedVisitor)
+    public LoopVisitor(DocumentWalker walker, ITemplateElementVisitor nestedVisitor, IWarningCollector warningCollector)
     {
         _walker = walker ?? throw new ArgumentNullException(nameof(walker));
         _nestedVisitor = nestedVisitor ?? throw new ArgumentNullException(nameof(nestedVisitor));
-        _valueResolver = new ValueResolver();
+        _warningCollector = warningCollector ?? throw new ArgumentNullException(nameof(warningCollector));
     }
 
     /// <summary>
@@ -61,7 +61,16 @@ public void VisitLoop(LoopBlock loop, IEvaluationContext context)
         // Resolve the collection from context
         if (!context.TryResolveVariable(loop.CollectionName, out object? collectionObj))
         {
-            // Collection not found - remove loop block
+            // Collection not found - remove loop block and report warning
+            _warningCollector.AddWarning(ProcessingWarning.MissingLoopCollection(loop.CollectionName));
+            RemoveLoopBlock(loop);
+            return;
+        }
+
+        // Handle null collection - treat same as missing (silent removal) and report warning
+        if (collectionObj == null)
+        {
+            _warningCollector.AddWarning(ProcessingWarning.NullLoopCollection(loop.CollectionName));
             RemoveLoopBlock(loop);
             return;
         }
diff --git a/TriasDev.Templify/Visitors/PlaceholderVisitor.cs b/TriasDev.Templify/Visitors/PlaceholderVisitor.cs
index d075c83..ba25fed 100644
--- a/TriasDev.Templify/Visitors/PlaceholderVisitor.cs
+++ b/TriasDev.Templify/Visitors/PlaceholderVisitor.cs
@@ -39,6 +39,7 @@ internal sealed class PlaceholderVisitor : ITemplateElementVisitor
 
     private readonly PlaceholderReplacementOptions _options;
     private readonly HashSet<string> _missingVariables;
+    private readonly IWarningCollector _warningCollector;
     private int _replacementCount;
 
     /// <summary>
@@ -46,10 +47,14 @@ internal sealed class PlaceholderVisitor : ITemplateElementVisitor
     /// </summary>
     public int ReplacementCount => _replacementCount;
 
-    public PlaceholderVisitor(PlaceholderReplacementOptions options, HashSet<string> missingVariables)
+    public PlaceholderVisitor(
+        PlaceholderReplacementOptions options,
+        HashSet<string> missingVariables,
+        IWarningCollector warningCollector)
     {
         _options = options ?? throw new ArgumentNullException(nameof(options));
         _missingVariables = missingVariables ?? throw new ArgumentNullException(nameof(missingVariables));
+        _warningCollector = warningCollector ?? throw new ArgumentNullException(nameof(warningCollector));
         _replacementCount = 0;
     }
 
@@ -112,6 +117,7 @@ public void VisitPlaceholder(PlaceholderMatch placeholder, Paragraph paragraph,
         {
             // Variable/expression not found - handle based on options
             _missingVariables.Add(placeholder.VariableName);
+            _warningCollector.AddWarning(ProcessingWarning.MissingVariable(placeholder.VariableName));
 
             switch (_options.MissingVariableBehavior)
             {
diff --git a/examples/outputs/warning-report-output.docx b/examples/outputs/warning-report-output.docx
new file mode 100644
index 0000000000000000000000000000000000000000..063781e54228325d07ac7409ba90143bb63a6285
GIT binary patch
literal 1587
zcmWIWW@Zs#U|`^2xX`8^llr7(MmQ4#L#hA+gCJ0}JijPKKP5l8G&eP`M6V(@=WRr;
z|7`<-f7)UDE^lGorMbv4s&$*Ev~%=PJL`{2H>Uj7`F&~1-(M#+H5YtUbx4?eOnm;D
zJGPbQ_C1$*{-$QBXmrzOp|d7ZylsNalNV1&GwjvU>bvLu{AJ`^jx*Z4Z8yBMA5X55
zn(AWKnLK~`f}QdUST|o<<*?lHC*v;Hn8m`^68Y|VZ@!=<$KO6VqBwIA!_0*{IIp!G
zG(8-eY$Uck{bQQfOPMX9a~fiEFWm5d=d<Dd!9|N7_`P0`mSd26U}yjR4gPzcTKXuz
zKF}QPG^LJ(xlg#GrMLa@$%_RgCN;<1CO`S2Vrln|ZEyFley{9zdE1(0l+4^8tvY)}
z{Y{Cy_^B&vch;6Kvs)nipvKtw^sAJUS53H1FIPw^eN^wecyfm9JVn7*f9<%qZoPl_
zWRcASrQYdGcBO^8?mZW=_c7cz|5w$S-MN9$o}Z<;qs1)pChmH4c7xFtX^k1SI+}mA
zu8Y>4o%>`a(|?H|Ypu*X%=0C+SS>wG>Std}T^e$}#Et#s8tylNkKS*Z%x^q<`T?#G
zuGa$Fa~?<V^37;wl9?gHGPx~~v**^a8KFmbgtRvp&0gLl?0+xn826T*GUuDB*KNP@
zIB%$OyM80?>gH3zSq1$|cQT*Tn&;f<)ljXuteN}l(yG*T=O=s<cd1?=`Zl<tPJE~D
zW3G$8%nSFw`+neV-oMwM{)rX+^;z)Sg3)=c>Kg7R!lLIm#a^g<ao@)M<g)6$n$$0A
z-+yJ4?R!0mJMED6w3yHb_xWD^k3JpF=Q=gG{*eXGj$o<!JF_oyD@%yA>)$P`Ufch^
zPIAe9#sFw4WB{kaG8@Z6Ek*_g5atG^!uX=poML@F5cz)hej9sWI#ei2Eh^5;&$CrB
z)H6_0NX<*mPsz+nw^b@FNz=7ZvbVDdO3g_u0jem@$Sf#U0BXrAwpGd~DJihh*Dp@a
zNX<<w*2^zQ%>&A$<rn29mH@d$>G}nU$=QkNsrp6+24?y|8xdwGp_-`>Qdy8njEVVa
zX_?8XF3?Pb#bA9@6-o*riACwDCALcX7}-xr!865HDabI*)ZECz!qP0w)Y2r)z*tE^
z-_AxK#m9E2L3&@BDLe`ooFFU=4AN-l{Jauio{k6kqBs_mwTTZ}upTmlG#O&AZVAX<
zV34|`rX`l<lqk4X0G$JgQJ`Ct6rk>d1ae|QK~82eI4bnZ@>0;^O&1b=@L~!SY6V64
z$*IM~z$B5IqX(DCP0Y;G1{)6yFDy2LQW$AgLz4?AZ6Z<%+zNegNCBgQkx7IZcPR^u
z4=`BL2%<0|9ibh2_JC++U|7=F1}wUfG7Gv!^hAKrc#|1xk_hl-WdkW<2Ev^{I)xR)
F0|1AaT2KH0

literal 0
HcmV?d00001

diff --git a/examples/templates/warning-report-template.docx b/examples/templates/warning-report-template.docx
new file mode 100644
index 0000000000000000000000000000000000000000..e7c5ddcac88b660159d08738821e5d338dfe342b
GIT binary patch
literal 1596
zcmWIWW@Zs#U|`^2xX`8^6aVy;Z~_wpLx&IpgCJ0}JijPKKP5l8G&eP`M6V(@=k1KZ
z?Arzc$M<&?%oi_B?nxAyzP9IUqIRnG+s!%ilN*;9U$XQ|`*pW{j)muKm9klDq;>R#
zw!Q!N%iHR|fK;5%)+FH#ev2eo^Vy#>GEYv>I$I$!Wy;>45-~1^wR{XUO(l|o*Y<F)
z4xAt?s`y;*q$9Wa0j4t{t9jOnJz>i@zQ<{{n3!;Z->i*cfA0SL$-b`Dq;YzW;oP75
zKJ@0!n!T)BvcIk7r^iLz7fzf^Wt&5izaNsi|G$Ar_h-Q@b<^C%kri`GYrFO}F=}&M
znsD{&r-#C}HeZ5oJo}Koa_ff8XO*%a-&f+iT2+3}<@2)Ijknp3W?j^6>%E%3MKj{M
zP2#~-1xi;mK5#ElNC<sV*W2{{ppC7Y(v{uGA}L#}51lH!C#cjrSu^G<=dRnLN96q{
zuJ^CKr}npO`P!+sBN?T|W^DJW{i?UoWJ~Oca_g9&FR|ycfA~dcCb8zp2a8<&>a^f&
z{-2yRb8BT|7X?k2;PN@hU%T~iZ0vL|*`$-t-@i|fOOIv<x}I*79Dd05X4BgJdFh5<
zHQUq$PBx~l5DBx(zw~S)myQ9qWP}0d5+5lyOM|SJlGBgy2%X+wa(ewr1;KeMKC`d5
zoTsr{?3c$4Lzc_V2ZFDsOGXKJo~ye0{@ec5U$^aVE_2zhRm~@L^=lF@-yyHq&quXn
zN-xRYd0_N9<w)_qH5cC}9IA2Fu`1ZbZE{kpSU5{0>7idw<=x3=v&{czo+=6b*lAqf
zYuta{L%-dpILz8C@tL}4ecnmeQ$6xYN+F!@N|JucXI@$!=C83bj#>5m;r%nFBwnl4
zKYV+({JveGU3JU>(B#MfPL5?ZmW5i33=AO54NQ*lMX5Q(`g$Pp{qFrX_P_+GP?lO$
zoSC0zt7NEWprnwRmz<xHnU`*>R9cdzYoTOsXA_i~lUM>&QJj%kP^<vdl2>f2lu=Sr
zV5P5LoSc!Gn^>%uUyzyylu64k%1tZ*a*NXS3lfvF6Vp@mjSLLT^no@a%uqr#Qz4|X
zAe9&s^V8BYlT%%wxe1HG`lu?D6hab<(o;)pmGm+4p^}1Uimg(RVVbGAk%fh&S(>S(
zNt%JNl7haSjXsKx?NEdCzBE&K6fihJSQr?j(a!mKCBV!b5AsEEEGUl?AGBaSWCm$6
z#9rMJkiEblbxBQ2EX^rVaIFA32NI(|w<sw<-3JNe#DapH%w%v>=$GZCpv9XmB>dpz
z6)4mSit>|Fi;ICtA~#15E|Z&>nWqgl9vEI&YzCz;(yWFi7f{+nq!hRn`rwcPMg=32
z2s7^D78oC3u%r=0VMIDYJNE1W(agZGq_H1Zh9hMbbdBhV0HN^_Gu9*#;LXYgQp5~|
LJArgAD~JaG#pzdm

literal 0
HcmV?d00001


From 1610b91577cc1c514fc9cf6556c682aaa651ed75 Mon Sep 17 00:00:00 2001
From: Vaceslav Ustinov <vaceslav.ustinov@gmail.com>
Date: Wed, 7 Jan 2026 17:16:56 +0100
Subject: [PATCH 2/5] fix: add ExpressionFailed warnings and ignore .vscode
 directory

- Add warnings when expression evaluation fails in PlaceholderVisitor
  (ArgumentException, InvalidOperationException, InvalidCastException,
  and parse failures now generate ExpressionFailed warnings)
- Add .vscode/ to .gitignore and remove settings.json from tracking
---
 .gitignore                                       |  3 +++
 .vscode/settings.json                            |  3 ---
 TriasDev.Templify/Visitors/PlaceholderVisitor.cs | 10 +++++++---
 3 files changed, 10 insertions(+), 6 deletions(-)
 delete mode 100644 .vscode/settings.json

diff --git a/.gitignore b/.gitignore
index 3be124b..7f859cf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,6 +30,9 @@ bld/
 
 # Visual Studio 2015 cache/options directory
 .vs/
+
+# VS Code user settings
+.vscode/
 # Uncomment if you have tasks that create the project's static files in wwwroot
 #wwwroot/
 
diff --git a/.vscode/settings.json b/.vscode/settings.json
deleted file mode 100644
index 865798a..0000000
--- a/.vscode/settings.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "cSpell.words": ["Templify", "Trias"]
-}
diff --git a/TriasDev.Templify/Visitors/PlaceholderVisitor.cs b/TriasDev.Templify/Visitors/PlaceholderVisitor.cs
index ba25fed..a7439fe 100644
--- a/TriasDev.Templify/Visitors/PlaceholderVisitor.cs
+++ b/TriasDev.Templify/Visitors/PlaceholderVisitor.cs
@@ -85,24 +85,28 @@ public void VisitPlaceholder(PlaceholderMatch placeholder, Paragraph paragraph,
                     value = result;
                     resolved = true;
                 }
-                catch (ArgumentException)
+                catch (ArgumentException ex)
                 {
+                    _warningCollector.AddWarning(ProcessingWarning.ExpressionFailed(placeholder.VariableName, ex.Message));
                     resolved = false;
                     value = null;
                 }
-                catch (InvalidOperationException)
+                catch (InvalidOperationException ex)
                 {
+                    _warningCollector.AddWarning(ProcessingWarning.ExpressionFailed(placeholder.VariableName, ex.Message));
                     resolved = false;
                     value = null;
                 }
-                catch (InvalidCastException)
+                catch (InvalidCastException ex)
                 {
+                    _warningCollector.AddWarning(ProcessingWarning.ExpressionFailed(placeholder.VariableName, ex.Message));
                     resolved = false;
                     value = null;
                 }
             }
             else
             {
+                _warningCollector.AddWarning(ProcessingWarning.ExpressionFailed(placeholder.VariableName, "Failed to parse expression"));
                 resolved = false;
                 value = null;
             }

From c76891bf5b34436013c36017d11c4a8fb3554842 Mon Sep 17 00:00:00 2001
From: Vaceslav Ustinov <vaceslav.ustinov@gmail.com>
Date: Wed, 7 Jan 2026 17:31:45 +0100
Subject: [PATCH 3/5] fix: add ExpressionFailed warnings to warning report

Address Copilot review comments by adding support for ExpressionFailed
warning type in the warning report:

- Add ExpressionFailed case to WarningReportGenerator switch statement
- Add "Failed Expressions" section to warning report template
- Add sample data for ExpressionFailed warnings in template generator
- Regenerate embedded WarningReportTemplate.docx resource
---
 .../WarningReportTemplateGenerator.cs         |  25 +++++++++++++++++-
 .../Core/WarningReportGenerator.cs            |   9 ++++++-
 .../Resources/WarningReportTemplate.docx      | Bin 1596 -> 1673 bytes
 examples/outputs/warning-report-output.docx   | Bin 1587 -> 1690 bytes
 .../templates/warning-report-template.docx    | Bin 1596 -> 1673 bytes
 5 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/TriasDev.Templify.DocumentGenerator/Generators/WarningReportTemplateGenerator.cs b/TriasDev.Templify.DocumentGenerator/Generators/WarningReportTemplateGenerator.cs
index b908075..e058e39 100644
--- a/TriasDev.Templify.DocumentGenerator/Generators/WarningReportTemplateGenerator.cs
+++ b/TriasDev.Templify.DocumentGenerator/Generators/WarningReportTemplateGenerator.cs
@@ -39,6 +39,7 @@ public override string GenerateTemplate(string outputDirectory)
             AddTableRow(summaryTable, "Missing Variables", "{{MissingVariableCount}}");
             AddTableRow(summaryTable, "Missing Collections", "{{MissingCollectionCount}}");
             AddTableRow(summaryTable, "Null Collections", "{{NullCollectionCount}}");
+            AddTableRow(summaryTable, "Failed Expressions", "{{FailedExpressionCount}}");
             body.AppendChild(summaryTable);
             AddEmptyParagraph(body);
 
@@ -87,6 +88,21 @@ public override string GenerateTemplate(string outputDirectory)
             AddEmptyParagraph(body);
             AddParagraph(body, "{{/if}}");
 
+            // Failed Expressions section (conditional)
+            AddParagraph(body, "{{#if HasFailedExpressions}}");
+            AddParagraph(body, "Failed Expressions", isBold: true);
+            AddParagraph(body, "The following expressions could not be evaluated:");
+            AddEmptyParagraph(body);
+
+            var failedExprTable = CreateTable(2);
+            AddTableHeaderRow(failedExprTable, "Expression", "Error");
+            AddTableRow(failedExprTable, "{{#foreach FailedExpressions}}", "");
+            AddTableRow(failedExprTable, "{{VariableName}}", "{{Message}}");
+            AddTableRow(failedExprTable, "{{/foreach}}", "");
+            body.AppendChild(failedExprTable);
+            AddEmptyParagraph(body);
+            AddParagraph(body, "{{/if}}");
+
             // Footer
             AddEmptyParagraph(body);
             AddParagraph(body, "End of Warning Report");
@@ -103,13 +119,15 @@ public override Dictionary<string, object> GetSampleData()
         return new Dictionary<string, object>
         {
             ["GeneratedAt"] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
-            ["TotalWarnings"] = 5,
+            ["TotalWarnings"] = 7,
             ["MissingVariableCount"] = 2,
             ["MissingCollectionCount"] = 2,
             ["NullCollectionCount"] = 1,
+            ["FailedExpressionCount"] = 2,
             ["HasMissingVariables"] = true,
             ["HasMissingCollections"] = true,
             ["HasNullCollections"] = true,
+            ["HasFailedExpressions"] = true,
             ["MissingVariables"] = new List<Dictionary<string, object>>
             {
                 new() { ["VariableName"] = "CustomerName", ["Context"] = "placeholder" },
@@ -123,6 +141,11 @@ public override Dictionary<string, object> GetSampleData()
             ["NullCollections"] = new List<Dictionary<string, object>>
             {
                 new() { ["VariableName"] = "Products", ["Context"] = "loop: Products" }
+            },
+            ["FailedExpressions"] = new List<Dictionary<string, object>>
+            {
+                new() { ["VariableName"] = "Price > 100", ["Message"] = "Variable 'Price' was not found in the data." },
+                new() { ["VariableName"] = "Status = \"Active\"", ["Message"] = "Variable 'Status' was not found in the data." }
             }
         };
     }
diff --git a/TriasDev.Templify/Core/WarningReportGenerator.cs b/TriasDev.Templify/Core/WarningReportGenerator.cs
index 838107c..a8d5be2 100644
--- a/TriasDev.Templify/Core/WarningReportGenerator.cs
+++ b/TriasDev.Templify/Core/WarningReportGenerator.cs
@@ -68,6 +68,7 @@ private static Dictionary<string, object> BuildReportData(IReadOnlyList<Processi
         List<Dictionary<string, object>> missingVariables = new();
         List<Dictionary<string, object>> missingCollections = new();
         List<Dictionary<string, object>> nullCollections = new();
+        List<Dictionary<string, object>> failedExpressions = new();
 
         foreach (ProcessingWarning warning in warnings)
         {
@@ -89,6 +90,9 @@ private static Dictionary<string, object> BuildReportData(IReadOnlyList<Processi
                 case ProcessingWarningType.NullLoopCollection:
                     nullCollections.Add(warningData);
                     break;
+                case ProcessingWarningType.ExpressionFailed:
+                    failedExpressions.Add(warningData);
+                    break;
             }
         }
 
@@ -99,12 +103,15 @@ private static Dictionary<string, object> BuildReportData(IReadOnlyList<Processi
             ["MissingVariableCount"] = missingVariables.Count,
             ["MissingCollectionCount"] = missingCollections.Count,
             ["NullCollectionCount"] = nullCollections.Count,
+            ["FailedExpressionCount"] = failedExpressions.Count,
             ["HasMissingVariables"] = missingVariables.Count > 0,
             ["HasMissingCollections"] = missingCollections.Count > 0,
             ["HasNullCollections"] = nullCollections.Count > 0,
+            ["HasFailedExpressions"] = failedExpressions.Count > 0,
             ["MissingVariables"] = missingVariables,
             ["MissingCollections"] = missingCollections,
-            ["NullCollections"] = nullCollections
+            ["NullCollections"] = nullCollections,
+            ["FailedExpressions"] = failedExpressions
         };
     }
 }
diff --git a/TriasDev.Templify/Resources/WarningReportTemplate.docx b/TriasDev.Templify/Resources/WarningReportTemplate.docx
index e7c5ddcac88b660159d08738821e5d338dfe342b..2562767d604ce3f7f554417cbf12a4e287398840 100644
GIT binary patch
delta 909
zcmdnP)5%*O;LXe;!oa}5!LX}aJtk-Wch|K{3=EOt3=D!m(enJF6#bO^<kH;Kyb`^N
z+?=;FV)JJkh_wChI=U{r{IZGfiiNjU<?W4Fowa&bHgkKz$sY>81uiZ8_x+?w%NE~;
znv%8K?%Zga^ZD0NyULW`PfBKKnlUD;zMA;`-HRK^3zU26m&*0;X_~Zs{+`PZmV8O>
z>Ebcjn7M4r*V7ZH3q7@aZsw&Z{Eegd!et-T3?s*H9A{@t&v<kvf#sT)?KzS9`kFrz
z)19);d$vj3-)UFgyK?sHUEGrVem@>fY?3}vq{?yQt5fe^A-CQC*q>yaXuYhnGB5k=
zotHYVgFo<^NH_}oUbCuRjDP;ie|0ksS+(1D>j*!~+j`>C4|5ME(|c=;1NUdfmE2ws
zaCZ044GVuYsj(%$RzDN@(!WKjGOtObV$GMg?<amgID2WkM@wXRPgBb-<sO;kwu(W~
zl828@Sa5rt!oLr~KR+!$e=Fn0E0e87#nTUWaX#z46tLG=$7HQ|QEa<6mtOtTHEsE=
z6O}>|%ne-~L(j6#`g802sarR%T$I#e74*DvyDCexth_W-V{5nS^!@(!@vR{On?Gmf
z$+T`OFbU3JZL6Af^`F#=(5uojH*hD)Pdyqn=Zn~n2~4#t+e9Loyb@o2QuCG5KFDA^
zp@C7>@ywF6DNKvoUL-pDC~sup-uuI}UQFc=Gw1xqma|Qpv?sphY@L;`i<@WlE8iwI
zmnoYZzwZ9`|7ykUJC4SSW>4j1=UtU$$8NoF>8c+!V&8sUw7v7d=w<4W;C(uRmFb6S
z+|N`C+-IG&;%rQ-RO^h}%*p@W<*klA8}2)EpO#(0v!fQD3+`{TO?mbA@jg!D+beg}
zdTS-sFS{!sypU@{yX@)z9+MTfRymyPUijo=V|Min9;-j46IpKgh$Sw3^y`5z6Z7%@
zUqP=5o>j6nZPDJwUol6zInDlsMA+>0{BqM1)=C`SUwSXm|Iqo;GX^jBXFNL_YL>tL
zWV1aifir*;xSiWkXDvns1`y^3Ch*N`nFJXHQZ0;(6O&ENOwtUDP14emC!b@MW7^fd
z`5kjNBOhwMnB2~4$N>@pnKbzTtC;m2V19`&O3f+O*8`CO-i%Bl%%Cg<vGKk%Q+O26
YHV_sDi$aJcjruH;1=&>DcCms40R9=4oB#j-

delta 814
zcmeC=-NREK;LXe;!oa}5!Em8XJtqF?E8zqt28IqH1_nW(XnB57ihfFda%paAUWr~s
zZqC~of!VhW1di|TDwr=`n%t8pG<|K)*F^19?YEnA<|j8UF}`H!m-g#!`y30;+bU(V
z)=2B<3vGM<@0YjLe*vjDpRGy48~heYvgWftXJnq7pjCgiLS)L6y+0*lTn=mb7;2hI
zBn7YS;a(j$L0DArx!y@fZu0|7XF^u<tQC90mT`QK(`+#@;R3%|8^iwG{rQu9U8_ms
z^d7^xKlgp;&7C!SS+`_=Tg^|8i@GnIIGM^eha`VLBz6CP1C#F0f?4XOxr-w!=9boW
z?Q3Gx=D0NB>eo*X>xFG?z69TR_91=c)(xA_DrG;uuf%z^s{EeI=Vi4UZ?hfEx~SXM
zdo_KFX2f-y#Dl8}l&)xe;9jDT5c;C7x9R&q8(TM}E4!0LQnpwhI#qa2P^ovaX3SU4
zUAIM#$oo%R?_YaQ?QhxgwNr0LGD?fh*zQ&PRd1uome>>J)-gd}V$WsQ|L}{@Ok&NG
z4;H!l)oH=m{69Hs=GMx_E()43!R2$1zjo{4*x2b_vPmbOzki<|mmbX!bUocDIsB0A
z&8D^c^U@8!YPP8hoNP>8ArfYnf9csqE*%4I$p{0^B|cJamIhfbC8r<Z5jwrW<n;QL
z3WD=id}d#9IZtD^*e{P8hAfwz57Y-=PnV1m@H|&__5HW~tG{mB-(2RhU#pr=>gv}d
zUcN(Kv7e7>$&_A_z4O56b;^<AeQPehPdHTLtYcNMi`(R+R<UrFNYX>Up31wE&t{qb
z&pcHU`mxivzSp?_yoY|fPjQ&FS>iKw(fYiTuBUqBlaxX@-<2f&l+V1hJj`EXWgN4b
z>iNU_XG}@FR;z#b_H6lmyF$C_m|<y>0h}hwY%B{mzhjbR6fjIPH8--bury0EwKPdH
zFrF;UBFA*0ZL>8?HzOZv@|}Ez)zBIw1k$a=$iM)?+`tqK14|nFf$2QHC^e^8Uk^kE
ecr!AIFoUuJ$lA#cY%)xbm?y`vsj}s=g2Vt4m{zp_

diff --git a/examples/outputs/warning-report-output.docx b/examples/outputs/warning-report-output.docx
index 063781e54228325d07ac7409ba90143bb63a6285..37c2838a71bf2dd9bbd69035c67a819735a44f33 100644
GIT binary patch
delta 913
zcmdnYGmE!Az?+#xgn@y9gJD;<dd%{LEVlcY7#KbQg#>}3<@rS^`YHLzrManjC3+RP
zId3Cw=iN5o`73&e|8;P(`i)y>vx9P6%NV!mMKr&Q+&0stK}AYPcKPpLj((H3Wa#BR
zE@Pf1&e?YIv2$npqS7+E%UsJc=Bixgy|q?@!9+9lQhm>E$AgO>Z$DW1eoc?D7k6)4
z;<BlQg*SQC&Q!{@>CIgrw$9aZ*32;FO;H=NC(5>~-qhJXWl`~^o~>Ngfh9s&ioOpN
zg-_-Ene+Q#*x?1UggC0xAAXux?R;gYP>(^xqJ#R0z4Pmn{HE=-JU@5U#zSXp&&B@f
zs(n*5G0FUduGN;{dY-EJ7Z-^3MDomCQCuXmwSRGN#{6S*%RkQcvwh)vWj)v0*1eJZ
zo4RjIh*;seM6c~~Zj43X_RDX#3xA!M({?S?e~PoDf9or@x}PF!0mt5zn^(x5xhtHc
zw)d{v!;bCI5tj4b7)(5Nl4t)F!(I2%MDFn$?vegg<MTTAqSE9xbIW!0kq-(QL&V=V
zaUGuB_-9M2>i2!8E8F6^wOtooux-22=JU$r!1Jalho-2`+<*4Prhrw6R&Q-z)CdJ7
zvi+UeUaY^(?sHFli0P`yQQwoL{RG^Wh)lhgzw1M@kZ#ja!6*~WGzH!dEREt*tu!Tg
z40~1>oZdb&K~O&HhVhjRN81i9y-?39YIxY<_Trwk=U;UnGR)l4zjP;~Ubxax&XqiG
ziw$$XZk_O|b>}<9xA`tV`)=*<efaWJ@!Vsgf$#Vp)!k%E-8%dKu08cXBK8}-QuA||
zpKW-hv1ZXB*2go}9C>!)T4T+wBdfP9&#XPqpHUy<@4|MhK1nO2@m)c{|NBvL5vRJQ
z%&r$co_Aom_u??_eZJy5KDA8Yni_gHyQv|L_v+IF3kz%6Y}b^n;ne)HcIh$egN;))
z53M%b-(DtSs?eUgxh}*}-cj?;ulY;EE^mz4_~4MEcoV<oX-&4?He>hu+Vk3P)faSL
ze?6NgW6N(ggP1#pZL5Euz9$b$@eH68&l+RrcGP+E3?^AdgH#J6<HTfBGm|s}W0SPB
zWF-ZCI~)C=)SSeU%>2CKjLd>!J7mq9pE7qd@}Xv%$#txT@*p9Qv097_3?R%6%t<h?
fr19<KbF5NKySgX8VwGWXV42Lprpk7j6(kP;=mD1I

delta 788
zcmV+v1MB>n4YLe?P)h>@6aWAK2msKACtPLZgqT+X003nW000pH004Jya%3-LZ)0_B
zWo~pXcx`O$SZz<+FcAJLR=(4;1-dDsL0W~jNgG33#XdXnrLkoDEc?=w{rbr%DWLTw
zKwy)`7oV)$J$cT)=N#wke5Dmzg7Xs1G#U+t5d)K>kY+J|jVdaR-bd%@S)B;XD-DL&
zN-N`&dK#5PHi=`Om!P>Hparwisz9eX`2o5`T%!}#VGiC)v(PFY4~LUjb7`UgnW4A|
z)`r0~!&PH47N=+NW=iQCv{jsdU2V|VPwq^x-@&4z;7;qHW^6ERz`2j#uur_@IZPw#
zz=K;tlzs$%1CA4jgpG&e$<c6hG<?TKljQUyIX><Ny^H#fN^9<Jwu2lZHb>&B&D1CC
zbRQSW)UCOFccwm|6X1L^L(A%9$<;Ip%cme>b>e?bqmyVIo*@zH{XPl`+VA1yqCDUt
zjh6yGb#c1h=M+CoF}|Prdd$0RQCms#8w*<&IBt=Dy5h~SGPD~gm^~~h{VLZLe$Aca
znF9Y9QadVX+ykE(Dg`-7G=H1XWu;WlbVdj1tPAW>;_tGP4>OyWzzS3f>kzkW<5&$2
zn1ccwm>dL?hEWNO+Qyhw#0(NEuriycf)h{PTE+{sjCMoWCD%Rm3`4MbM%UP0)w9YI
zYH*K#rMUynDxO1$N`QMQrh^O3rFvzq&ye;PM0=nW?NfMu7r9O23eoyEalh{Oz};^C
z>+=2<a{Wx8`#1qZttG4r<P#On2^Q!i^hdS}<kKbId}Z{l@AUy4j_Z;OX2L6$Tvg!T
z4(k6~%U2FXl~aG>I1IQ`8h_lI(+eXQ7Kbk#-En)ZkMDjNq`v`BO9KQH000000MLdf
zTy{J;akKvd9RUzAW;Hi5I5;^rW;Ho9W-v38ECe0`(1x>21d9O<(1s^mW#ojIR{{V4
zWe}6)1u+QFh9_KhJUMZb9tIX2h5`TpUvgz^b1yD(Wo&a$O928D0~7!N0002chLceS
S90J(`lWztk24n>Q0001Y$XOi#

diff --git a/examples/templates/warning-report-template.docx b/examples/templates/warning-report-template.docx
index e7c5ddcac88b660159d08738821e5d338dfe342b..2562767d604ce3f7f554417cbf12a4e287398840 100644
GIT binary patch
delta 909
zcmdnP)5%*O;LXe;!oa}5!LX}aJtk-Wch|K{3=EOt3=D!m(enJF6#bO^<kH;Kyb`^N
z+?=;FV)JJkh_wChI=U{r{IZGfiiNjU<?W4Fowa&bHgkKz$sY>81uiZ8_x+?w%NE~;
znv%8K?%Zga^ZD0NyULW`PfBKKnlUD;zMA;`-HRK^3zU26m&*0;X_~Zs{+`PZmV8O>
z>Ebcjn7M4r*V7ZH3q7@aZsw&Z{Eegd!et-T3?s*H9A{@t&v<kvf#sT)?KzS9`kFrz
z)19);d$vj3-)UFgyK?sHUEGrVem@>fY?3}vq{?yQt5fe^A-CQC*q>yaXuYhnGB5k=
zotHYVgFo<^NH_}oUbCuRjDP;ie|0ksS+(1D>j*!~+j`>C4|5ME(|c=;1NUdfmE2ws
zaCZ044GVuYsj(%$RzDN@(!WKjGOtObV$GMg?<amgID2WkM@wXRPgBb-<sO;kwu(W~
zl828@Sa5rt!oLr~KR+!$e=Fn0E0e87#nTUWaX#z46tLG=$7HQ|QEa<6mtOtTHEsE=
z6O}>|%ne-~L(j6#`g802sarR%T$I#e74*DvyDCexth_W-V{5nS^!@(!@vR{On?Gmf
z$+T`OFbU3JZL6Af^`F#=(5uojH*hD)Pdyqn=Zn~n2~4#t+e9Loyb@o2QuCG5KFDA^
zp@C7>@ywF6DNKvoUL-pDC~sup-uuI}UQFc=Gw1xqma|Qpv?sphY@L;`i<@WlE8iwI
zmnoYZzwZ9`|7ykUJC4SSW>4j1=UtU$$8NoF>8c+!V&8sUw7v7d=w<4W;C(uRmFb6S
z+|N`C+-IG&;%rQ-RO^h}%*p@W<*klA8}2)EpO#(0v!fQD3+`{TO?mbA@jg!D+beg}
zdTS-sFS{!sypU@{yX@)z9+MTfRymyPUijo=V|Min9;-j46IpKgh$Sw3^y`5z6Z7%@
zUqP=5o>j6nZPDJwUol6zInDlsMA+>0{BqM1)=C`SUwSXm|Iqo;GX^jBXFNL_YL>tL
zWV1aifir*;xSiWkXDvns1`y^3Ch*N`nFJXHQZ0;(6O&ENOwtUDP14emC!b@MW7^fd
z`5kjNBOhwMnB2~4$N>@pnKbzTtC;m2V19`&O3f+O*8`CO-i%Bl%%Cg<vGKk%Q+O26
YHV_sDi$aJcjruH;1=&>DcCms40R9=4oB#j-

delta 814
zcmeC=-NREK;LXe;!oa}5!Em8XJtqF?E8zqt28IqH1_nW(XnB57ihfFda%paAUWr~s
zZqC~of!VhW1di|TDwr=`n%t8pG<|K)*F^19?YEnA<|j8UF}`H!m-g#!`y30;+bU(V
z)=2B<3vGM<@0YjLe*vjDpRGy48~heYvgWftXJnq7pjCgiLS)L6y+0*lTn=mb7;2hI
zBn7YS;a(j$L0DArx!y@fZu0|7XF^u<tQC90mT`QK(`+#@;R3%|8^iwG{rQu9U8_ms
z^d7^xKlgp;&7C!SS+`_=Tg^|8i@GnIIGM^eha`VLBz6CP1C#F0f?4XOxr-w!=9boW
z?Q3Gx=D0NB>eo*X>xFG?z69TR_91=c)(xA_DrG;uuf%z^s{EeI=Vi4UZ?hfEx~SXM
zdo_KFX2f-y#Dl8}l&)xe;9jDT5c;C7x9R&q8(TM}E4!0LQnpwhI#qa2P^ovaX3SU4
zUAIM#$oo%R?_YaQ?QhxgwNr0LGD?fh*zQ&PRd1uome>>J)-gd}V$WsQ|L}{@Ok&NG
z4;H!l)oH=m{69Hs=GMx_E()43!R2$1zjo{4*x2b_vPmbOzki<|mmbX!bUocDIsB0A
z&8D^c^U@8!YPP8hoNP>8ArfYnf9csqE*%4I$p{0^B|cJamIhfbC8r<Z5jwrW<n;QL
z3WD=id}d#9IZtD^*e{P8hAfwz57Y-=PnV1m@H|&__5HW~tG{mB-(2RhU#pr=>gv}d
zUcN(Kv7e7>$&_A_z4O56b;^<AeQPehPdHTLtYcNMi`(R+R<UrFNYX>Up31wE&t{qb
z&pcHU`mxivzSp?_yoY|fPjQ&FS>iKw(fYiTuBUqBlaxX@-<2f&l+V1hJj`EXWgN4b
z>iNU_XG}@FR;z#b_H6lmyF$C_m|<y>0h}hwY%B{mzhjbR6fjIPH8--bury0EwKPdH
zFrF;UBFA*0ZL>8?HzOZv@|}Ez)zBIw1k$a=$iM)?+`tqK14|nFf$2QHC^e^8Uk^kE
ecr!AIFoUuJ$lA#cY%)xbm?y`vsj}s=g2Vt4m{zp_


From 0338a14ffb94ab6e8aa4a5a6eb856fd727b47e04 Mon Sep 17 00:00:00 2001
From: Vaceslav Ustinov <vaceslav.ustinov@gmail.com>
Date: Wed, 7 Jan 2026 21:23:36 +0100
Subject: [PATCH 4/5] fix: add ExpressionFailed tests and improve GUI warning
 display

Address remaining Copilot review comments:

- Add integration tests for ExpressionFailed warnings (parse failures)
- Add test for valid expressions (no warning expected)
- Improve GUI warning summary to include truncated message text
  instead of just type and variable name
---
 .../ViewModels/MainWindowViewModel.cs         | 13 ++++-
 .../ProcessingWarningsIntegrationTests.cs     | 52 +++++++++++++++++++
 2 files changed, 64 insertions(+), 1 deletion(-)

diff --git a/TriasDev.Templify.Gui/ViewModels/MainWindowViewModel.cs b/TriasDev.Templify.Gui/ViewModels/MainWindowViewModel.cs
index 82693d7..4bf14c4 100644
--- a/TriasDev.Templify.Gui/ViewModels/MainWindowViewModel.cs
+++ b/TriasDev.Templify.Gui/ViewModels/MainWindowViewModel.cs
@@ -212,7 +212,8 @@ private async Task ProcessTemplateAsync()
                     Results.Add($"⚠ {result.Processing.Warnings.Count} processing warnings:");
                     foreach (ProcessingWarning warning in result.Processing.Warnings.Take(5))
                     {
-                        Results.Add($"  - {warning.Type}: {warning.VariableName}");
+                        string truncatedMessage = TruncateMessage(warning.Message, 60);
+                        Results.Add($"  - {warning.Type}: {warning.VariableName} - {truncatedMessage}");
                     }
                     if (result.Processing.Warnings.Count > 5)
                     {
@@ -355,4 +356,14 @@ private string GenerateOutputFileName()
 
         return "output.docx";
     }
+
+    private static string TruncateMessage(string message, int maxLength)
+    {
+        if (string.IsNullOrEmpty(message) || message.Length <= maxLength)
+        {
+            return message;
+        }
+
+        return message[..(maxLength - 3)] + "...";
+    }
 }
diff --git a/TriasDev.Templify.Tests/Integration/ProcessingWarningsIntegrationTests.cs b/TriasDev.Templify.Tests/Integration/ProcessingWarningsIntegrationTests.cs
index 4bbc6aa..8f7a9f7 100644
--- a/TriasDev.Templify.Tests/Integration/ProcessingWarningsIntegrationTests.cs
+++ b/TriasDev.Templify.Tests/Integration/ProcessingWarningsIntegrationTests.cs
@@ -254,6 +254,58 @@ public void ProcessTemplate_NestedMissingVariable_CollectsWarning()
         Assert.Equal("Customer.Name", result.Warnings[0].VariableName);
     }
 
+    [Fact]
+    public void ProcessTemplate_InvalidExpressionSyntax_CollectsWarning()
+    {
+        // Arrange - expression with invalid syntax (= instead of ==)
+        // This causes parse failure which generates ExpressionFailed warning
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("{{(Status = \"Active\")}}");
+
+        Dictionary<string, object> data = new Dictionary<string, object>();
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        Assert.True(result.HasWarnings);
+
+        // Should have ExpressionFailed warning for parse failure
+        // Note: Also generates MissingVariable warning because resolved=false
+        Assert.Contains(result.Warnings, w => w.Type == ProcessingWarningType.ExpressionFailed);
+        ProcessingWarning exprWarning = result.Warnings.First(w => w.Type == ProcessingWarningType.ExpressionFailed);
+        Assert.Equal("(Status = \"Active\")", exprWarning.VariableName);
+        Assert.Contains("expression", exprWarning.Context);
+    }
+
+    [Fact]
+    public void ProcessTemplate_ValidExpression_NoExpressionFailedWarning()
+    {
+        // Arrange - valid expression that evaluates successfully (even with missing variable)
+        // Note: Missing variables in expressions just return null/false, no exception
+        DocumentBuilder builder = new DocumentBuilder();
+        builder.AddParagraph("{{(Price > 100)}}");
+
+        Dictionary<string, object> data = new Dictionary<string, object>();
+
+        using MemoryStream templateStream = builder.ToStream();
+        using MemoryStream outputStream = new MemoryStream();
+
+        // Act
+        DocumentTemplateProcessor processor = new DocumentTemplateProcessor();
+        ProcessingResult result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+        // Assert - valid expression evaluates to false (null > 100), no warning
+        Assert.True(result.IsSuccess);
+        Assert.False(result.HasWarnings);
+        Assert.DoesNotContain(result.Warnings, w => w.Type == ProcessingWarningType.ExpressionFailed);
+    }
+
     #region Warning Report Tests
 
     [Fact]

From 7ca32229336f00bfc142b1ac0bdd342222c6c1a9 Mon Sep 17 00:00:00 2001
From: Vaceslav Ustinov <vaceslav.ustinov@gmail.com>
Date: Wed, 7 Jan 2026 21:25:28 +0100
Subject: [PATCH 5/5] docs: add processing warnings documentation for
 developers

Add new documentation page covering:
- How to access warnings from ProcessingResult
- Warning types (MissingVariable, MissingLoopCollection,
  NullLoopCollection, ExpressionFailed)
- Warning properties
- Generating warning reports as Word documents
- Example code for logging warnings
- Behavior notes and edge cases
---
 docs/for-developers/processing-warnings.md | 110 +++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 docs/for-developers/processing-warnings.md

diff --git a/docs/for-developers/processing-warnings.md b/docs/for-developers/processing-warnings.md
new file mode 100644
index 0000000..f42a1f9
--- /dev/null
+++ b/docs/for-developers/processing-warnings.md
@@ -0,0 +1,110 @@
+# Processing Warnings
+
+Templify collects non-fatal warnings during template processing, helping you identify issues like missing variables or null collections without failing the entire operation.
+
+## Accessing Warnings
+
+Warnings are available on the `ProcessingResult` returned by `ProcessTemplate`:
+
+```csharp
+var processor = new DocumentTemplateProcessor();
+var result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+if (result.IsSuccess)
+{
+    Console.WriteLine($"Processed with {result.Warnings.Count} warnings");
+
+    if (result.HasWarnings)
+    {
+        foreach (var warning in result.Warnings)
+        {
+            Console.WriteLine($"  [{warning.Type}] {warning.VariableName}: {warning.Message}");
+        }
+    }
+}
+```
+
+## Warning Types
+
+| Type | Description | When Generated |
+|------|-------------|----------------|
+| `MissingVariable` | Variable not found in data | Placeholder like `{{CustomerName}}` when `CustomerName` is not in the data dictionary |
+| `MissingLoopCollection` | Loop collection not found | `{{#foreach Items}}` when `Items` is not in the data dictionary |
+| `NullLoopCollection` | Loop collection is null | `{{#foreach Items}}` when `Items` exists but is `null` |
+| `ExpressionFailed` | Expression parsing or evaluation failed | `{{(Status = "Active")}}` with invalid syntax (should be `==`) |
+
+## Warning Properties
+
+Each `ProcessingWarning` contains:
+
+```csharp
+public class ProcessingWarning
+{
+    public ProcessingWarningType Type { get; }    // Warning category
+    public string VariableName { get; }           // The variable/expression that caused the warning
+    public string Context { get; }                // Where it occurred (e.g., "placeholder", "loop: Items")
+    public string Message { get; }                // Human-readable description
+}
+```
+
+## Generating Warning Reports
+
+Templify can generate a Word document report of all warnings:
+
+```csharp
+var result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+if (result.HasWarnings)
+{
+    // Get report as MemoryStream
+    using var reportStream = result.GetWarningReport();
+
+    // Or get report as byte array
+    byte[] reportBytes = result.GetWarningReportBytes();
+    File.WriteAllBytes("warnings.docx", reportBytes);
+}
+```
+
+The generated report includes:
+
+- Summary with total warning counts by type
+- Detailed sections for each warning type
+- Variable names, contexts, and error messages
+
+## Example: Logging All Warnings
+
+```csharp
+var result = processor.ProcessTemplate(templateStream, outputStream, data);
+
+if (result.HasWarnings)
+{
+    _logger.LogWarning("Template processed with {Count} warnings", result.Warnings.Count);
+
+    foreach (var warning in result.Warnings)
+    {
+        switch (warning.Type)
+        {
+            case ProcessingWarningType.MissingVariable:
+                _logger.LogWarning("Missing variable: {Variable}", warning.VariableName);
+                break;
+            case ProcessingWarningType.MissingLoopCollection:
+                _logger.LogWarning("Missing collection: {Collection}", warning.VariableName);
+                break;
+            case ProcessingWarningType.NullLoopCollection:
+                _logger.LogWarning("Null collection: {Collection}", warning.VariableName);
+                break;
+            case ProcessingWarningType.ExpressionFailed:
+                _logger.LogWarning("Expression failed: {Expression} - {Message}",
+                    warning.VariableName, warning.Message);
+                break;
+        }
+    }
+}
+```
+
+## Behavior Notes
+
+- **Empty collections** do not generate warnings (they're valid, just produce no output)
+- **Valid expressions with missing variables** evaluate to `false` without warnings (e.g., `{{(Price > 100)}}` where `Price` is missing returns `false`)
+- **Invalid expression syntax** generates `ExpressionFailed` (e.g., using `=` instead of `==`)
+- Warnings are collected even when `MissingVariableBehavior` is set to `LeaveUnchanged` or `ReplaceWithEmpty`