Add DFTE sources and tests

.gitignore

@@ -0,0 +1,24 @@
+# PlatformIO build artifacts
+.pio/
+.ccls-cache/
+.clangd/
+.cmake/
+cmake-build*/
+.pnpm-store/
+
+# VS Code / CLion configuration
+.vscode/
+.idea/
+
+# macOS / Windows
+.DS_Store
+Thumbs.db
+
+# Coverage / profiling
+*.gcda
+*.gcno
+*.gcov
+
+# Temporary files
+*.swp
+*.swo

README.md

@@ -0,0 +1,27 @@
+# Device Framework Template Engine (DFTE)
+
+Device Framework Template Engine provides a lightweight templating layer for Arduino-based projects within the Device Framework ecosystem. It exposes a registry for dynamic placeholders, a rendering engine, and utilities for composing nested templates.
+
+## Structure
+
+- `include/` and `src/` contain the core template engine components.
+- `test/test_template_engine/` hosts PlatformIO-based unit tests covering placeholder registration, context handling, renderer behaviours, and integration scenarios.
+
+## Getting Started
+
+The library is distributed as a PlatformIO library. To use it in another PlatformIO project, add the repository as a dependency in your `platformio.ini`:
+
+```
+lib_deps =
+    alexhopeoconnor/DFTE
+```
+
+To develop locally or contribute, clone the repository and run the tests through PlatformIO:
+
+```
+pio test -e test_template_engine
+```
+
+## License
+
+This project is released under the MIT License. See `LICENSE` for details.

include/DeviceFrameworkPlaceholderRegistry.h

@@ -0,0 +1,144 @@
+#ifndef DEVICEFRAMEWORK_PLACEHOLDER_REGISTRY_H
+#define DEVICEFRAMEWORK_PLACEHOLDER_REGISTRY_H
+
+#include <Arduino.h>
+#include <stdio.h>
+#include "DeviceFrameworkTemplateTypes.h"
+
+// Fallback defaults when DeviceFrameworkConfig is not available (standalone usage)
+// Always use internal macro names (DFTE_*) to avoid conflicts with DeviceFrameworkConfig extern declarations
+// When DeviceFrameworkConfig is included, extern variables are declared with CONFIG_* names
+// We use DFTE_* internal names for compile-time constants (constexpr) and default parameter values
+// NEVER define CONFIG_* macros here to avoid conflicts with extern declarations in DeviceFrameworkConfig
+#ifndef DFTE_PLACEHOLDER_NAME_SIZE_DEFAULT
+  #define DFTE_PLACEHOLDER_NAME_SIZE_DEFAULT 24
+#endif
+
+#ifndef DFTE_MAX_PLACEHOLDERS_DEFAULT
+  #define DFTE_MAX_PLACEHOLDERS_DEFAULT 16
+#endif
+
+#ifndef DFTE_PROGMEM_CHUNK_SIZE_DEFAULT
+  #define DFTE_PROGMEM_CHUNK_SIZE_DEFAULT 512
+#endif
+
+#ifndef DFTE_RAM_CHUNK_SIZE_DEFAULT
+  #define DFTE_RAM_CHUNK_SIZE_DEFAULT 128
+#endif
+
+// Use DeviceFramework config defaults at compile-time if available, otherwise use internal defaults
+#ifdef DEVICEFRAMEWORK_CONFIG_H
+  // DeviceFramework is present - use config defaults
+  // DeviceFrameworkConfig.h must be included before this file to access CONFIG_*_default macros
+  #ifdef CONFIG_templateProgmemChunkSize_default
+    #define DFTE_PROGMEM_CHUNK_SIZE CONFIG_templateProgmemChunkSize_default
+  #else
+    #define DFTE_PROGMEM_CHUNK_SIZE DFTE_PROGMEM_CHUNK_SIZE_DEFAULT
+  #endif
+  #ifdef CONFIG_templateRamChunkSize_default
+    #define DFTE_RAM_CHUNK_SIZE CONFIG_templateRamChunkSize_default
+  #else
+    #define DFTE_RAM_CHUNK_SIZE DFTE_RAM_CHUNK_SIZE_DEFAULT
+  #endif
+#else
+  // Standalone usage - use internal defaults
+  #define DFTE_PROGMEM_CHUNK_SIZE DFTE_PROGMEM_CHUNK_SIZE_DEFAULT
+  #define DFTE_RAM_CHUNK_SIZE DFTE_RAM_CHUNK_SIZE_DEFAULT
+#endif
+
+/**
+ * DeviceFramework Placeholder Registry
+ * Manages runtime registration of template placeholders
+ * Registry starts empty - users must register their placeholders
+ */
+class DeviceFrameworkPlaceholderRegistry {
+public:
+    /**
+     * Constructor with optional max placeholders parameter
+     * @param maxPlaceholders Maximum number of placeholders (defaults to DFTE_MAX_PLACEHOLDERS_DEFAULT)
+     *                        Allows creating multiple registries with different sizes
+     *                        When using with DeviceFramework, pass getConfigMaxTemplatePlaceholders() for runtime config
+     */
+    explicit DeviceFrameworkPlaceholderRegistry(uint16_t maxPlaceholders = DFTE_MAX_PLACEHOLDERS_DEFAULT);
+    
+    ~DeviceFrameworkPlaceholderRegistry();
+    
+    // Prevent copying
+    DeviceFrameworkPlaceholderRegistry(const DeviceFrameworkPlaceholderRegistry&) = delete;
+    DeviceFrameworkPlaceholderRegistry& operator=(const DeviceFrameworkPlaceholderRegistry&) = delete;
+    
+    /**
+     * Register a PROGMEM data placeholder
+     * @param name Placeholder name (e.g., "%CSS%")
+     * @param progmemData Pointer to PROGMEM data
+     * @return true if registered successfully, false if registry full
+     */
+    bool registerProgmemData(const char* name, const char* progmemData);
+    
+    /**
+     * Register a PROGMEM template placeholder (nested template)
+     * @param name Placeholder name (e.g., "%HEADER%")
+     * @param progmemTemplate Pointer to PROGMEM template
+     * @return true if registered successfully
+     */
+    bool registerProgmemTemplate(const char* name, const char* progmemTemplate);
+    
+    /**
+     * Register a RAM data placeholder with getter function
+     * @param name Placeholder name (e.g., "%PAGE_TITLE%")
+     * @param getter Function that returns current value
+     * @return true if registered successfully
+     */
+    bool registerRamData(const char* name, PlaceholderDataGetter getter);
+    bool registerDynamicTemplate(const char* name, const DynamicTemplateDescriptor* descriptor);
+    bool registerConditional(const char* name, const ConditionalDescriptor* descriptor);
+    bool registerIterator(const char* name, const IteratorDescriptor* descriptor);
+    
+    /**
+     * Clear all registered placeholders
+     */
+    void clear();
+    
+    /**
+     * Get number of registered placeholders
+     */
+    int getCount() const { return count; }
+    
+    /**
+     * Get maximum number of placeholders
+     */
+    uint16_t getMaxPlaceholders() const { return maxPlaceholders; }
+    
+    /**
+     * Find placeholder entry by name
+     * @return PlaceholderEntry pointer or nullptr if not found
+     */
+    const PlaceholderEntry* getPlaceholder(const char* name) const;
+    
+    /**
+     * Render placeholder content at given offset
+     */
+    size_t renderPlaceholder(const PlaceholderEntry* entry, size_t offset, 
+                            uint8_t* buffer, size_t maxLen) const;
+    
+    // Static helper functions for length calculation
+    static size_t getProgmemLength(const void* data);
+    static size_t getRamLength(const void* data);
+    static size_t getDynamicTemplateLength(const DynamicTemplateDescriptor* descriptor, const char* templateData);
+    
+private:
+    static constexpr uint16_t MAX_PLACEHOLDER_NAME_SIZE = DFTE_PLACEHOLDER_NAME_SIZE_DEFAULT;
+    
+    PlaceholderEntry* placeholders;  // Dynamically allocated array
+    uint16_t maxPlaceholders;        // Configurable size
+    int count;
+    
+    bool validatePlaceholderName(const char* name) const;
+    static size_t copyProgmemData(const char* source, size_t offset, 
+                                 uint8_t* dest, size_t maxLen);
+    static size_t copyRamData(PlaceholderDataGetter getter, size_t offset, 
+                             uint8_t* dest, size_t maxLen);
+};
+
+#endif // DEVICEFRAMEWORK_PLACEHOLDER_REGISTRY_H
+

include/DeviceFrameworkTemplateContext.h

@@ -0,0 +1,114 @@
+#ifndef DEVICEFRAMEWORK_TEMPLATE_CONTEXT_H
+#define DEVICEFRAMEWORK_TEMPLATE_CONTEXT_H
+
+#include <Arduino.h>
+#include "DeviceFrameworkTemplateTypes.h"
+
+// Fallback defaults when DeviceFrameworkConfig is not available (standalone usage)
+// Always use internal macro names (DFTE_*) to avoid conflicts with DeviceFrameworkConfig extern declarations
+// When DeviceFrameworkConfig is included, extern variables are declared with CONFIG_* names
+// We use DFTE_* internal names for compile-time constants (constexpr) and array sizes
+#ifndef DFTE_MAX_STACK_DEPTH_DEFAULT
+  #define DFTE_MAX_STACK_DEPTH_DEFAULT 16
+#endif
+
+#ifndef DFTE_BUFFER_SIZE_DEFAULT
+  #define DFTE_BUFFER_SIZE_DEFAULT 512
+#endif
+
+#ifndef DFTE_PLACEHOLDER_NAME_SIZE_DEFAULT
+  #define DFTE_PLACEHOLDER_NAME_SIZE_DEFAULT 24
+#endif
+
+// Use DeviceFramework config defaults at compile-time if available, otherwise use internal defaults
+// Array sizes must be compile-time constants
+#ifdef DEVICEFRAMEWORK_CONFIG_H
+  // DeviceFramework is present - use config defaults for array sizing
+  // DeviceFrameworkConfig.h must be included before this file to access CONFIG_*_default macros
+  #ifdef CONFIG_templateStackDepth_default
+    #define DFTE_MAX_STACK_DEPTH CONFIG_templateStackDepth_default
+  #else
+    #define DFTE_MAX_STACK_DEPTH DFTE_MAX_STACK_DEPTH_DEFAULT
+  #endif
+  #ifdef CONFIG_templateBufferSize_default
+    #define DFTE_BUFFER_SIZE CONFIG_templateBufferSize_default
+  #else
+    #define DFTE_BUFFER_SIZE DFTE_BUFFER_SIZE_DEFAULT
+  #endif
+  // DFTE_PLACEHOLDER_NAME_SIZE is already defined in DeviceFrameworkTemplateTypes.h
+#else
+  // Standalone usage - use internal defaults
+  #define DFTE_MAX_STACK_DEPTH DFTE_MAX_STACK_DEPTH_DEFAULT
+  #define DFTE_BUFFER_SIZE DFTE_BUFFER_SIZE_DEFAULT
+  // DFTE_PLACEHOLDER_NAME_SIZE is already defined in DeviceFrameworkTemplateTypes.h
+#endif
+
+// Forward declaration
+class DeviceFrameworkPlaceholderRegistry;
+
+/**
+ * Template rendering context
+ * Maintains state for chunked streaming rendering with nested template support
+ */
+class DeviceFrameworkTemplateContext {
+public:
+    using State = TemplateRenderState;
+    
+    // Context state
+    State state;
+    
+    // Unified rendering stack
+    static constexpr int MAX_RENDERING_DEPTH = DFTE_MAX_STACK_DEPTH;
+    RenderingContext renderingStack[MAX_RENDERING_DEPTH];
+    int renderingDepth;
+    
+    // Current placeholder being built (only valid during BUILDING_PLACEHOLDER state)
+    // Allocated to configured size - matches CONFIG_templatePlaceholderNameSize when DeviceFramework is present
+    char placeholderName[DFTE_PLACEHOLDER_NAME_SIZE];
+    size_t placeholderPos;
+    
+    // Centralized buffer management
+    // Allocated to configured size - matches CONFIG_templateBufferSize when DeviceFramework is present
+    static const size_t BUFFER_SIZE = DFTE_BUFFER_SIZE;
+    uint8_t readBuffer[BUFFER_SIZE];
+    size_t bufferPos;
+    size_t bufferLen;
+    size_t bufferOffset;
+    
+    // Placeholder registry (injected, not owned)
+    DeviceFrameworkPlaceholderRegistry* registry;
+    
+    // Statistics
+    size_t totalBytesProcessed;
+    unsigned long startTime;
+    
+    DeviceFrameworkTemplateContext();
+    void reset();
+    
+    // Unified stack management methods
+    bool pushContext(RenderingContextType type, const char* name);
+    void popContext();
+    RenderingContext* getCurrentContext();
+    RenderingContext* getContext(int depth);
+    bool isRenderingTemplate() const;
+    bool isRenderingPlaceholder() const;
+    RenderingContextType getCurrentContextType() const;
+    
+    bool isComplete() const;
+    bool hasError() const;
+    String getStateString() const;
+    String getStackTrace() const;
+    
+    // Set the registry to use for placeholder lookups
+    void setRegistry(DeviceFrameworkPlaceholderRegistry* reg) { registry = reg; }
+    
+    // Unified buffer management
+    bool refillBuffer();
+    char getNextChar();
+    size_t getAvailableBytes() const;
+    bool hasMoreData() const;
+    void resetPlaceholder();
+};
+
+#endif // DEVICEFRAMEWORK_TEMPLATE_CONTEXT_H
+

include/DeviceFrameworkTemplateEngineDebug.h

@@ -0,0 +1,121 @@
+#ifndef DEVICEFRAMEWORK_TEMPLATE_ENGINE_DEBUG_H
+#define DEVICEFRAMEWORK_TEMPLATE_ENGINE_DEBUG_H
+
+#include <Arduino.h>
+
+// ============================================================================
+// LOGGING INTERFACE - Framework Agnostic
+// ============================================================================
+
+/**
+ * Logging interface for the DeviceFramework Template Engine
+ * 
+ * This interface allows any logging system to be plugged into the template engine.
+ * The template engine itself remains completely framework-agnostic.
+ * 
+ * Usage:
+ * 1. Implement this interface with your preferred logging system
+ * 2. Call deviceFrameworkTemplateEngineEnableLogging() with your logger instance
+ * 3. All DFTE_LOG_* macros will then use your logger
+ * 
+ * Example:
+ *   class MyLogger : public DeviceFrameworkTemplateEngineLogger {
+ *       void error(const String& msg) override { // your logging logic }
+ *       void warn(const String& msg) override { // your logging logic }
+ *       void info(const String& msg) override { // your logging logic }
+ *       void debug(const String& msg) override { // your logging logic }
+ *   };
+ *   
+ *   MyLogger myLogger;
+ *   deviceFrameworkTemplateEngineEnableLogging(&myLogger);
+ */
+class DeviceFrameworkTemplateEngineLogger {
+public:
+    virtual void error(const String& msg) = 0;
+    virtual void warn(const String& msg) = 0;
+    virtual void info(const String& msg) = 0;
+    virtual void debug(const String& msg) = 0;
+    virtual ~DeviceFrameworkTemplateEngineLogger() {}
+};
+
+// Global logger pointer - set by user or defaults to nullptr (disabled)
+extern DeviceFrameworkTemplateEngineLogger* deviceFrameworkTemplateEngineLogger;
+
+// ============================================================================
+// LOGGING MACROS - NO-OPS BY DEFAULT
+// ============================================================================
+
+/**
+ * DeviceFramework Template Engine Logging System
+ * 
+ * LOGGING IS DISABLED BY DEFAULT - All macros are no-ops unless explicitly enabled
+ * 
+ * To enable logging:
+ * 1. Implement the DeviceFrameworkTemplateEngineLogger interface with your preferred logging system
+ * 2. Call deviceFrameworkTemplateEngineEnableLogging() with your logger instance
+ * 
+ * This design ensures:
+ * - Zero logging overhead by default
+ * - Complete framework decoupling
+ * - Flexible logging system integration
+ * - No build flags or conditional compilation needed
+ */
+
+// All logging macros are no-ops by default - zero overhead unless explicitly enabled
+#define DFTE_LOG_ERROR(msg) do { \
+    if (deviceFrameworkTemplateEngineLogger) { \
+        deviceFrameworkTemplateEngineLogger->error(msg); \
+    } \
+} while(0)
+
+#define DFTE_LOG_WARN(msg) do { \
+    if (deviceFrameworkTemplateEngineLogger) { \
+        deviceFrameworkTemplateEngineLogger->warn(msg); \
+    } \
+} while(0)
+
+#define DFTE_LOG_INFO(msg) do { \
+    if (deviceFrameworkTemplateEngineLogger) { \
+        deviceFrameworkTemplateEngineLogger->info(msg); \
+    } \
+} while(0)
+
+#define DFTE_LOG_DEBUG(msg) do { \
+    if (deviceFrameworkTemplateEngineLogger) { \
+        deviceFrameworkTemplateEngineLogger->debug(msg); \
+    } \
+} while(0)
+
+// ============================================================================
+// LOGGING CONFIGURATION FUNCTIONS
+// ============================================================================
+
+/**
+ * Enable logging with a custom logger implementation
+ * 
+ * @param logger Pointer to custom logger implementation
+ * @return true if logging was enabled, false if logger is null
+ */
+bool deviceFrameworkTemplateEngineEnableLogging(DeviceFrameworkTemplateEngineLogger* logger);
+
+/**
+ * Disable all logging
+ * Sets logger to nullptr, making all DFTE_LOG_* macros no-ops
+ */
+void deviceFrameworkTemplateEngineDisableLogging();
+
+/**
+ * Check if logging is currently enabled
+ * 
+ * @return true if logging is enabled, false if disabled
+ */
+bool deviceFrameworkTemplateEngineIsLoggingEnabled();
+
+/**
+ * Get current logger
+ * 
+ * @return Pointer to current logger or nullptr if disabled
+ */
+DeviceFrameworkTemplateEngineLogger* deviceFrameworkTemplateEngineGetLogger();
+
+#endif // DEVICEFRAMEWORK_TEMPLATE_ENGINE_DEBUG_H

include/DeviceFrameworkTemplateRenderer.h

@@ -0,0 +1,111 @@
+#ifndef DEVICEFRAMEWORK_TEMPLATE_RENDERER_H
+#define DEVICEFRAMEWORK_TEMPLATE_RENDERER_H
+
+#include <Arduino.h>
+#include "DeviceFrameworkTemplateContext.h"
+#include "DeviceFrameworkPlaceholderRegistry.h"
+
+// Fallback defaults when DeviceFrameworkConfig is not available (standalone usage)
+#ifndef DFTE_MAX_ITERATIONS_DEFAULT
+  #define DFTE_MAX_ITERATIONS_DEFAULT 50
+#endif
+
+// Use DeviceFramework config defaults at compile-time if available, otherwise use internal defaults
+#ifdef DEVICEFRAMEWORK_CONFIG_H
+  // DeviceFramework is present - use config defaults
+  // DeviceFrameworkConfig.h must be included before this file to access CONFIG_*_default macros
+  #ifdef CONFIG_templateMaxIterations_default
+    #define DFTE_MAX_ITERATIONS CONFIG_templateMaxIterations_default
+  #else
+    #define DFTE_MAX_ITERATIONS DFTE_MAX_ITERATIONS_DEFAULT
+  #endif
+#else
+  // Standalone usage - use internal defaults
+  #define DFTE_MAX_ITERATIONS DFTE_MAX_ITERATIONS_DEFAULT
+#endif
+
+/**
+ * DeviceFramework Template Renderer
+ * Core rendering engine for streaming template output with chunked processing
+ */
+class DeviceFrameworkTemplateRenderer {
+public:
+    struct RenderOutcome {
+        size_t bytesWritten;
+        TemplateRenderState nextState;
+        bool repeat;
+        bool finished;
+        bool errored;
+        uint8_t popCount;
+        struct {
+            bool active;
+            RenderingContextType type;
+            const PlaceholderEntry* entry;
+        } pushContext;
+    };
+
+    /**
+     * Render next chunk of template
+     * Call repeatedly until returns 0
+     *
+     * @param ctx Rendering context (maintains state between calls)
+     * @param buffer Output buffer to write to
+     * @param maxLen Maximum bytes to write to buffer
+     * @return Number of bytes written (0 = complete or error)
+     */
+    static size_t renderNextChunk(DeviceFrameworkTemplateContext& ctx, uint8_t* buffer, size_t maxLen);
+
+    /**
+     * Initialize rendering context with template stored in PROGMEM
+     * Call once before rendering begins
+     *
+     * @param ctx Context to initialize
+     * @param templateData Pointer to PROGMEM template string
+     */
+    static void initializeContext(DeviceFrameworkTemplateContext& ctx, const char* templateData);
+
+    /**
+     * Initialize rendering context with template stored in RAM or PROGMEM
+     *
+     * @param ctx Context to initialize
+     * @param templateData Pointer to template string
+     * @param templateInProgmem True if template is stored in PROGMEM, false if in RAM
+     */
+    static void initializeContext(DeviceFrameworkTemplateContext& ctx, const char* templateData, bool templateInProgmem);
+
+    /**
+     * Check if rendering is complete
+     */
+    static bool isComplete(const DeviceFrameworkTemplateContext& ctx);
+
+    /**
+     * Check if rendering encountered an error
+     */
+    static bool hasError(const DeviceFrameworkTemplateContext& ctx);
+
+    /**
+     * Helper constructors for RenderOutcome
+     */
+    static RenderOutcome makeWritten(size_t bytes, TemplateRenderState state, bool repeat = false);
+    static RenderOutcome makeState(TemplateRenderState nextState, bool repeat = true);
+    static RenderOutcome makeComplete();
+    static RenderOutcome makeError();
+
+private:
+    static RenderOutcome renderChunk(DeviceFrameworkTemplateContext& ctx, uint8_t* buffer, size_t maxLen);
+    static bool applyStackCommands(DeviceFrameworkTemplateContext& ctx, const RenderOutcome& outcome);
+
+    // Core processing methods
+    static RenderOutcome consumeTemplateText(DeviceFrameworkTemplateContext& ctx, uint8_t* buffer, size_t maxLen);
+    static RenderOutcome buildPlaceholderToken(DeviceFrameworkTemplateContext& ctx);
+    static RenderOutcome resolvePlaceholder(DeviceFrameworkTemplateContext& ctx);
+    static RenderOutcome emitActiveContext(DeviceFrameworkTemplateContext& ctx, uint8_t* buffer, size_t maxLen);
+    static RenderOutcome streamPlaceholderData(DeviceFrameworkTemplateContext& ctx, RenderingContext* context, uint8_t* buffer, size_t maxLen);
+    static RenderOutcome handleTemplateCompletion(DeviceFrameworkTemplateContext& ctx);
+
+    // Constants
+    static constexpr size_t MAX_ITERATIONS = DFTE_MAX_ITERATIONS;
+};
+
+#endif // DEVICEFRAMEWORK_TEMPLATE_RENDERER_H
+

include/DeviceFrameworkTemplateTypes.h

@@ -0,0 +1,204 @@
+#ifndef DEVICEFRAMEWORK_TEMPLATE_TYPES_H
+#define DEVICEFRAMEWORK_TEMPLATE_TYPES_H
+
+#include <Arduino.h>
+
+// Fallback defaults when DeviceFrameworkConfig is not available (standalone usage)
+// Always use internal macro names (DFTE_*) to avoid conflicts with DeviceFrameworkConfig extern declarations
+#ifndef DFTE_PLACEHOLDER_NAME_SIZE_DEFAULT
+  #define DFTE_PLACEHOLDER_NAME_SIZE_DEFAULT 24
+#endif
+
+// Use DeviceFramework config defaults at compile-time if available, otherwise use internal defaults
+// Array sizes must be compile-time constants
+#ifdef DEVICEFRAMEWORK_CONFIG_H
+  // DeviceFramework is present - use config defaults for array sizing
+  // DeviceFrameworkConfig.h must be included before this file to access CONFIG_*_default macros
+  #ifdef CONFIG_templatePlaceholderNameSize_default
+    #define DFTE_PLACEHOLDER_NAME_SIZE CONFIG_templatePlaceholderNameSize_default
+  #else
+    #define DFTE_PLACEHOLDER_NAME_SIZE DFTE_PLACEHOLDER_NAME_SIZE_DEFAULT
+  #endif
+#else
+  // Standalone usage - use internal defaults
+  #define DFTE_PLACEHOLDER_NAME_SIZE DFTE_PLACEHOLDER_NAME_SIZE_DEFAULT
+#endif
+
+/**
+ * Placeholder types for template substitution
+ */
+enum class PlaceholderType {
+    PROGMEM_DATA,      // Large PROGMEM data (CSS, JS, base64 images)
+    PROGMEM_TEMPLATE,  // Nested template in PROGMEM
+    RAM_DATA,           // Dynamic RAM data via getter functions
+    DYNAMIC_TEMPLATE,
+    CONDITIONAL,
+    ITERATOR
+};
+
+/**
+ * Function pointer types for placeholder data access
+ */
+typedef const char* (*PlaceholderDataGetter)();
+typedef size_t (*PlaceholderLengthGetter)(const void* data);
+typedef const char* (*DynamicTemplateGetter)(void* userData);
+typedef size_t (*DynamicTemplateLengthGetter)(const char* data, void* userData);
+
+enum class ConditionalBranchResult {
+    SKIP,
+    TRUE_BRANCH,
+    FALSE_BRANCH
+};
+
+typedef ConditionalBranchResult (*ConditionalEvaluator)(void* userData);
+
+enum class IteratorStepResult {
+    ITEM_READY,
+    COMPLETE,
+    ERROR
+};
+
+struct IteratorItemView;
+
+typedef void* (*IteratorOpenHandler)(void* userData);
+typedef IteratorStepResult (*IteratorNextHandler)(void* handle, struct IteratorItemView& view);
+typedef void (*IteratorCloseHandler)(void* handle);
+
+struct DynamicTemplateDescriptor {
+    DynamicTemplateGetter getter;
+    DynamicTemplateLengthGetter getLength;
+    void* userData;
+};
+
+struct ConditionalDescriptor {
+    ConditionalEvaluator evaluate;
+    const char* truePlaceholder;
+    const char* falsePlaceholder;
+    void* userData;
+};
+
+/**
+ * Placeholder definition entry
+ * Represents a single registered placeholder in the registry
+ */
+struct PlaceholderEntry {
+    // Allocated to configured size - matches CONFIG_templatePlaceholderNameSize when DeviceFramework is present
+    char name[DFTE_PLACEHOLDER_NAME_SIZE];
+    PlaceholderType type;
+    const void* data;
+    PlaceholderLengthGetter getLength;
+    
+    PlaceholderEntry() 
+        : type(PlaceholderType::RAM_DATA), 
+          data(nullptr), 
+          getLength(nullptr) {
+        name[0] = '\0';
+    }
+};
+
+struct IteratorItemView {
+    const char* templateData;
+    size_t templateLength;
+    bool templateIsProgmem;
+    const PlaceholderEntry* placeholders;
+    size_t placeholderCount;
+};
+
+struct IteratorDescriptor {
+    IteratorOpenHandler open;
+    IteratorNextHandler next;
+    IteratorCloseHandler close;
+    void* userData;
+};
+
+/**
+ * Rendering context types - what kind of thing are we currently rendering?
+ */
+enum class RenderingContextType {
+    TEMPLATE,              // Rendering a template (contains placeholders)
+    PLACEHOLDER_DATA,      // Rendering a data placeholder (PROGMEM_DATA, RAM_DATA)
+    PLACEHOLDER_TEMPLATE,   // Rendering a template placeholder (resolved to template)
+    PLACEHOLDER_DYNAMIC_TEMPLATE,
+    PLACEHOLDER_CONDITIONAL,
+    PLACEHOLDER_ITERATOR
+};
+
+/**
+ * Unified rendering context entry
+ * Represents any active rendering context (template or placeholder)
+ * Note: Uses PlaceholderEntry which is defined above
+ */
+struct RenderingContext {
+    RenderingContextType type;
+    const char* name;  // Placeholder name or template identifier
+    
+    // Type-specific data (using union to save memory)
+    union {
+        // TEMPLATE context
+        struct {
+            const char* templateData;  // Pointer to PROGMEM or RAM template data (not a copy)
+            size_t templateLen;        // Length of template in bytes
+            bool isProgmem;            // Storage location flag
+            size_t position;           // Current position in template
+            size_t bufferPos;         // Current position in buffer
+            size_t bufferLen;          // Current buffer length
+            size_t bufferOffset;       // Offset in template where buffer starts
+            const PlaceholderEntry* iteratorPlaceholders;
+            size_t iteratorPlaceholderCount;
+        } templateCtx;
+        
+        // PLACEHOLDER_DATA context
+        struct {
+            const PlaceholderEntry* entry;
+            size_t offset;  // Current offset in data
+        } data;
+        
+        // PLACEHOLDER_TEMPLATE context
+        struct {
+            const PlaceholderEntry* entry;
+            // Template state is stored in nested TEMPLATE context
+        } templatePlaceholder;
+
+        struct {
+            const PlaceholderEntry* entry;
+            size_t offset;
+            const char* templateData;
+            size_t templateLength;
+        } dynamicTemplate;
+
+        struct {
+            const PlaceholderEntry* entry;
+            const ConditionalDescriptor* descriptor;
+            bool branchResolved;
+            const char* delegateName;
+            const PlaceholderEntry* delegateEntry;
+        } conditional;
+
+        struct {
+            const PlaceholderEntry* entry;
+            const IteratorDescriptor* descriptor;
+            void* handle;
+            bool initialized;
+            bool handleOpen;
+        } iterator;
+    } context;
+    
+    RenderingContext() 
+        : type(RenderingContextType::TEMPLATE), name(nullptr) {
+        memset(&context, 0, sizeof(context));
+    }
+};
+
+/**
+ * Template rendering state
+ */
+enum class TemplateRenderState {
+    TEXT,                    // Reading normal text in current context
+    BUILDING_PLACEHOLDER,    // Building placeholder name between % and %
+    RENDERING_CONTEXT,       // Rendering current context (unified for all context types)
+    COMPLETE,                // All rendering complete
+    ERROR                    // Error state
+};
+
+#endif // DEVICEFRAMEWORK_TEMPLATE_TYPES_H
+

include/TemplateEngine.h

@@ -0,0 +1,55 @@
+#ifndef TEMPLATE_ENGINE_H
+#define TEMPLATE_ENGINE_H
+
+/**
+ * DeviceFramework Template Engine
+ * Main public API header - include this in your projects
+ * 
+ * Memory-efficient streaming template renderer for ESP8266/ESP32
+ * Supports chunked rendering with PROGMEM templates and nested template support
+ * 
+ * Usage:
+ *   1. Create a PlaceholderRegistry and register your placeholders
+ *   2. Create a TemplateContext
+ *   3. Set the registry on the context
+ *   4. Initialize with your template
+ *   5. Call renderNextChunk() repeatedly until complete
+ * 
+ * Example:
+ *   DeviceFrameworkPlaceholderRegistry registry;
+ *   registry.registerProgmemData("%CSS%", my_css);
+ *   
+ *   DeviceFrameworkTemplateContext ctx;
+ *   ctx.setRegistry(&registry);
+ *   DeviceFrameworkTemplateRenderer::initializeContext(ctx, my_template);
+ *   
+ *   uint8_t buffer[512];
+ *   while (!DeviceFrameworkTemplateRenderer::isComplete(ctx)) {
+ *       size_t written = DeviceFrameworkTemplateRenderer::renderNextChunk(ctx, buffer, sizeof(buffer));
+ *       server->sendContent((const char*)buffer, written);
+ *   }
+ */
+
+// Type definitions first
+#include "DeviceFrameworkTemplateTypes.h"
+
+// Core components
+#include "DeviceFrameworkTemplateRenderer.h"
+#include "DeviceFrameworkTemplateContext.h"
+#include "DeviceFrameworkPlaceholderRegistry.h"
+#include "DeviceFrameworkTemplateEngineDebug.h"
+
+// Type aliases for convenience
+using TemplateRenderer = DeviceFrameworkTemplateRenderer;
+using TemplateContext = DeviceFrameworkTemplateContext;
+using PlaceholderRegistry = DeviceFrameworkPlaceholderRegistry;
+
+// Use new type names
+using PlaceholderType = PlaceholderType;
+using PlaceholderEntry = PlaceholderEntry;
+using RenderingContextType = RenderingContextType;
+using RenderingContext = RenderingContext;
+using TemplateRenderState = TemplateRenderState;
+
+#endif // TEMPLATE_ENGINE_H
+

library.json

@@ -0,0 +1,33 @@
+{
+  "name": "DeviceFrameworkTemplateEngine",
+  "version": "1.0.0",
+  "description": "Memory-efficient streaming template engine for ESP8266/ESP32 with chunked rendering support. Designed for embedded web interfaces with PROGMEM template support.",
+  "keywords": [
+    "template",
+    "engine",
+    "streaming",
+    "chunked",
+    "embedded",
+    "esp8266",
+    "esp32",
+    "html",
+    "rendering",
+    "low-memory",
+    "progmem",
+    "web-interface"
+  ],
+  "authors": [
+    {
+      "name": "Alex Hope-O'Connor",
+      "email": "alex.hope.oconnor@pomonaqld.au"
+    }
+  ],
+  "license": "MIT",
+  "frameworks": "arduino",
+  "platforms": ["espressif8266", "espressif32"],
+  "dependencies": {},
+  "export": {
+    "include": ["include"]
+  }
+}
+

platformio.ini

@@ -0,0 +1,6 @@
+[env:test_template_engine]
+platform = espressif8266
+board = d1_mini
+framework = arduino
+test_framework = unity
+test_build_src = yes

src/DeviceFrameworkPlaceholderRegistry.cpp

@@ -0,0 +1,294 @@
+#include "DeviceFrameworkPlaceholderRegistry.h"
+#include "DeviceFrameworkTemplateEngineDebug.h"
+#include <pgmspace.h>
+
+DeviceFrameworkPlaceholderRegistry::DeviceFrameworkPlaceholderRegistry(uint16_t maxPlaceholders) 
+    : maxPlaceholders(maxPlaceholders), count(0) {
+    placeholders = new PlaceholderEntry[maxPlaceholders];
+    memset(placeholders, 0, sizeof(PlaceholderEntry) * maxPlaceholders);
+}
+
+DeviceFrameworkPlaceholderRegistry::~DeviceFrameworkPlaceholderRegistry() {
+    if (placeholders) {
+        delete[] placeholders;
+        placeholders = nullptr;
+    }
+}
+
+bool DeviceFrameworkPlaceholderRegistry::registerProgmemData(const char* name, const char* progmemData) {
+    if (count >= maxPlaceholders) {
+        DFTE_LOG_ERROR("Placeholder registry full, cannot register: " + String(name));
+        return false;
+    }
+    
+    if (!validatePlaceholderName(name)) {
+        return false;
+    }
+    
+    // Check for duplicates
+    if (getPlaceholder(name) != nullptr) {
+        DFTE_LOG_WARN("Placeholder already registered: " + String(name));
+        // Continue anyway - last registration wins
+    }
+    
+    PlaceholderEntry& entry = placeholders[count];
+    strncpy(entry.name, name, sizeof(entry.name) - 1);
+    entry.name[sizeof(entry.name) - 1] = '\0';
+    entry.type = PlaceholderType::PROGMEM_DATA;
+    entry.data = progmemData;
+    entry.getLength = getProgmemLength;
+    
+    count++;
+    return true;
+}
+
+bool DeviceFrameworkPlaceholderRegistry::registerProgmemTemplate(const char* name, const char* progmemTemplate) {
+    if (count >= maxPlaceholders) {
+        DFTE_LOG_ERROR("Placeholder registry full, cannot register: " + String(name));
+        return false;
+    }
+    
+    if (!validatePlaceholderName(name)) {
+        return false;
+    }
+    
+    PlaceholderEntry& entry = placeholders[count];
+    strncpy(entry.name, name, sizeof(entry.name) - 1);
+    entry.name[sizeof(entry.name) - 1] = '\0';
+    entry.type = PlaceholderType::PROGMEM_TEMPLATE;
+    entry.data = progmemTemplate;
+    entry.getLength = getProgmemLength;
+    
+    count++;
+    return true;
+}
+
+bool DeviceFrameworkPlaceholderRegistry::registerRamData(const char* name, PlaceholderDataGetter getter) {
+    if (count >= maxPlaceholders) {
+        DFTE_LOG_ERROR("Placeholder registry full, cannot register: " + String(name));
+        return false;
+    }
+    
+    if (!validatePlaceholderName(name)) {
+        return false;
+    }
+
+    if (getter == nullptr) {
+        DFTE_LOG_ERROR("Cannot register RAM_DATA placeholder with null getter: " + String(name));
+        return false;
+    }
+    
+    PlaceholderEntry& entry = placeholders[count];
+    strncpy(entry.name, name, sizeof(entry.name) - 1);
+    entry.name[sizeof(entry.name) - 1] = '\0';
+    entry.type = PlaceholderType::RAM_DATA;
+    entry.data = (const void*)getter;
+    entry.getLength = getRamLength;
+    
+    count++;
+    return true;
+}
+
+bool DeviceFrameworkPlaceholderRegistry::registerDynamicTemplate(const char* name, const DynamicTemplateDescriptor* descriptor) {
+    if (count >= maxPlaceholders) {
+        DFTE_LOG_ERROR("Placeholder registry full, cannot register: " + String(name));
+        return false;
+    }
+
+    if (!validatePlaceholderName(name)) {
+        return false;
+    }
+
+    if (descriptor == nullptr || descriptor->getter == nullptr) {
+        DFTE_LOG_ERROR("Invalid dynamic template descriptor for placeholder: " + String(name));
+        return false;
+    }
+
+    PlaceholderEntry& entry = placeholders[count];
+    strncpy(entry.name, name, sizeof(entry.name) - 1);
+    entry.name[sizeof(entry.name) - 1] = '\0';
+    entry.type = PlaceholderType::DYNAMIC_TEMPLATE;
+    entry.data = descriptor;
+    entry.getLength = nullptr;
+
+    count++;
+    return true;
+}
+
+bool DeviceFrameworkPlaceholderRegistry::registerConditional(const char* name, const ConditionalDescriptor* descriptor) {
+    if (count >= maxPlaceholders) {
+        DFTE_LOG_ERROR("Placeholder registry full, cannot register: " + String(name));
+        return false;
+    }
+
+    if (!validatePlaceholderName(name)) {
+        return false;
+    }
+
+    if (descriptor == nullptr || descriptor->evaluate == nullptr) {
+        DFTE_LOG_ERROR("Invalid conditional descriptor for placeholder: " + String(name));
+        return false;
+    }
+
+    PlaceholderEntry& entry = placeholders[count];
+    strncpy(entry.name, name, sizeof(entry.name) - 1);
+    entry.name[sizeof(entry.name) - 1] = '\0';
+    entry.type = PlaceholderType::CONDITIONAL;
+    entry.data = descriptor;
+    entry.getLength = nullptr;
+
+    count++;
+    return true;
+}
+
+bool DeviceFrameworkPlaceholderRegistry::registerIterator(const char* name, const IteratorDescriptor* descriptor) {
+    if (count >= maxPlaceholders) {
+        DFTE_LOG_ERROR("Placeholder registry full, cannot register: " + String(name));
+        return false;
+    }
+
+    if (!validatePlaceholderName(name)) {
+        return false;
+    }
+
+    if (descriptor == nullptr || descriptor->next == nullptr) {
+        DFTE_LOG_ERROR("Invalid iterator descriptor for placeholder: " + String(name));
+        return false;
+    }
+
+    PlaceholderEntry& entry = placeholders[count];
+    strncpy(entry.name, name, sizeof(entry.name) - 1);
+    entry.name[sizeof(entry.name) - 1] = '\0';
+    entry.type = PlaceholderType::ITERATOR;
+    entry.data = descriptor;
+    entry.getLength = nullptr;
+
+    count++;
+    return true;
+}
+
+void DeviceFrameworkPlaceholderRegistry::clear() {
+    count = 0;
+    memset(placeholders, 0, sizeof(PlaceholderEntry) * maxPlaceholders);
+}
+
+bool DeviceFrameworkPlaceholderRegistry::validatePlaceholderName(const char* name) const {
+    if (!name) {
+        DFTE_LOG_ERROR("Placeholder name is null");
+        return false;
+    }
+    
+    size_t nameLen = strlen(name);
+    if (nameLen >= MAX_PLACEHOLDER_NAME_SIZE) {
+        DFTE_LOG_ERROR("Placeholder name too long: " + String(name) + " (max: " + String(MAX_PLACEHOLDER_NAME_SIZE) + ")");
+        return false;
+    }
+    
+    if (nameLen >= sizeof(PlaceholderEntry::name)) {
+        // This shouldn't happen if MAX_PLACEHOLDER_NAME_SIZE is <= sizeof(PlaceholderEntry::name)
+        DFTE_LOG_ERROR("Placeholder name exceeds entry buffer size");
+        return false;
+    }
+    
+    return true;
+}
+
+const PlaceholderEntry* DeviceFrameworkPlaceholderRegistry::getPlaceholder(const char* name) const {
+    if (name == nullptr) return nullptr;
+    
+    for (int i = count - 1; i >= 0; i--) {
+        if (strcmp(placeholders[i].name, name) == 0) {
+            return &placeholders[i];
+        }
+    }
+    return nullptr;
+}
+
+size_t DeviceFrameworkPlaceholderRegistry::renderPlaceholder(const PlaceholderEntry* entry, size_t offset, 
+                                             uint8_t* buffer, size_t maxLen) const {
+    if (entry == nullptr || maxLen == 0) {
+        return 0;
+    }
+    
+    switch (entry->type) {
+        case PlaceholderType::PROGMEM_DATA:
+        case PlaceholderType::PROGMEM_TEMPLATE:
+            return copyProgmemData((const char*)entry->data, offset, buffer, maxLen);
+            
+        case PlaceholderType::RAM_DATA:
+            return copyRamData((PlaceholderDataGetter)entry->data, offset, buffer, maxLen);
+
+        case PlaceholderType::DYNAMIC_TEMPLATE:
+        case PlaceholderType::CONDITIONAL:
+        case PlaceholderType::ITERATOR:
+            // Dynamic template, conditional, and iterator content are handled directly by the renderer
+            return 0;
+            
+        default:
+            return 0;
+    }
+}
+
+size_t DeviceFrameworkPlaceholderRegistry::getProgmemLength(const void* data) {
+    if (data == nullptr) return 0;
+    return strlen_P((const char*)data);
+}
+
+size_t DeviceFrameworkPlaceholderRegistry::getRamLength(const void* data) {
+    if (data == nullptr) return 0;
+    
+    PlaceholderDataGetter getter = (PlaceholderDataGetter)data;
+    const char* str = getter();
+    if (str == nullptr) {
+        return 0;
+    }
+    return strlen(str);
+}
+
+size_t DeviceFrameworkPlaceholderRegistry::getDynamicTemplateLength(const DynamicTemplateDescriptor* descriptor, const char* templateData) {
+    if (descriptor == nullptr || templateData == nullptr) {
+        return 0;
+    }
+
+    if (descriptor->getLength) {
+        return descriptor->getLength(templateData, descriptor->userData);
+    }
+
+    return strlen(templateData);
+}
+
+size_t DeviceFrameworkPlaceholderRegistry::copyProgmemData(const char* source, size_t offset, uint8_t* dest, size_t maxLen) {
+    if (source == nullptr || maxLen == 0) return 0;
+    
+    size_t dataLen = strlen_P(source);
+    if (offset >= dataLen) return 0;
+    
+    size_t remaining = dataLen - offset;
+    // Use configurable chunk size - matches CONFIG_templateProgmemChunkSize when DeviceFramework is present
+    constexpr size_t MAX_CHUNK = DFTE_PROGMEM_CHUNK_SIZE;
+    size_t chunkSize = min(min(maxLen, remaining), MAX_CHUNK);
+    
+    memcpy_P(dest, source + offset, chunkSize);
+    return chunkSize;
+}
+
+size_t DeviceFrameworkPlaceholderRegistry::copyRamData(PlaceholderDataGetter getter, size_t offset, uint8_t* dest, size_t maxLen) {
+    if (getter == nullptr || maxLen == 0) return 0;
+    
+    const char* data = getter();
+    if (data == nullptr) {
+        return 0;
+    }
+    size_t dataLen = strlen(data);
+    
+    if (offset >= dataLen) return 0;
+    
+    size_t remaining = dataLen - offset;
+    // Use configurable chunk size - matches CONFIG_templateRamChunkSize when DeviceFramework is present
+    constexpr size_t MAX_CHUNK = DFTE_RAM_CHUNK_SIZE;
+    size_t chunkSize = min(min(maxLen, remaining), MAX_CHUNK);
+    
+    memcpy(dest, data + offset, chunkSize);
+    return chunkSize;
+}
+

src/DeviceFrameworkTemplateContext.cpp

@@ -0,0 +1,260 @@
+#include "DeviceFrameworkTemplateContext.h"
+#include "DeviceFrameworkTemplateEngineDebug.h"
+
+DeviceFrameworkTemplateContext::DeviceFrameworkTemplateContext() 
+    : state(TemplateRenderState::TEXT), renderingDepth(0), placeholderPos(0),
+      bufferPos(0), bufferLen(0), bufferOffset(0),
+      registry(nullptr),
+      totalBytesProcessed(0), startTime(0) {
+    memset(placeholderName, 0, sizeof(placeholderName));
+    memset(renderingStack, 0, sizeof(renderingStack));
+}
+
+void DeviceFrameworkTemplateContext::reset() {
+    state = TemplateRenderState::TEXT;
+    renderingDepth = 0;
+    placeholderPos = 0;
+    bufferPos = 0;
+    bufferLen = 0;
+    bufferOffset = 0;
+    totalBytesProcessed = 0;
+    startTime = millis();
+    memset(placeholderName, 0, sizeof(placeholderName));
+    memset(renderingStack, 0, sizeof(renderingStack));
+}
+
+// Unified stack management methods
+bool DeviceFrameworkTemplateContext::pushContext(RenderingContextType type, const char* name) {
+    if (renderingDepth >= MAX_RENDERING_DEPTH) {
+        DFTE_LOG_ERROR("Rendering stack overflow! Depth=" + String(renderingDepth));
+        state = TemplateRenderState::ERROR;
+        return false;
+    }
+    
+    // Save current buffer state if we're currently in a template context
+    if (renderingDepth > 0) {
+        RenderingContext* currentCtx = getCurrentContext();
+        if (currentCtx && currentCtx->type == RenderingContextType::TEMPLATE) {
+            // Save buffer state to current template context
+            currentCtx->context.templateCtx.bufferPos = bufferPos;
+            currentCtx->context.templateCtx.bufferLen = bufferLen;
+            currentCtx->context.templateCtx.bufferOffset = bufferOffset;
+        }
+    }
+    
+    RenderingContext& ctx = renderingStack[renderingDepth];
+    ctx.type = type;
+    ctx.name = name;
+    
+    // Initialize buffer state for new template context
+    if (type == RenderingContextType::TEMPLATE) {
+        ctx.context.templateCtx.bufferPos = 0;
+        ctx.context.templateCtx.bufferLen = 0;
+        ctx.context.templateCtx.bufferOffset = 0;
+        ctx.context.templateCtx.iteratorPlaceholders = nullptr;
+        ctx.context.templateCtx.iteratorPlaceholderCount = 0;
+        bufferPos = 0;
+        bufferLen = 0;
+        bufferOffset = 0;
+    }
+    
+    renderingDepth++;
+    return true;
+}
+
+void DeviceFrameworkTemplateContext::popContext() {
+    if (renderingDepth <= 0) {
+        DFTE_LOG_ERROR("Rendering stack underflow!");
+        state = TemplateRenderState::ERROR;
+        return;
+    }
+    
+    renderingDepth--;
+    RenderingContext& ctx = renderingStack[renderingDepth];
+
+    if (ctx.type == RenderingContextType::PLACEHOLDER_ITERATOR) {
+        const IteratorDescriptor* descriptor = ctx.context.iterator.descriptor;
+        if (descriptor && descriptor->close && ctx.context.iterator.handleOpen) {
+            descriptor->close(ctx.context.iterator.handle);
+        }
+    }
+    
+    // Restore buffer state from parent template context if it exists
+    if (renderingDepth > 0) {
+        RenderingContext* parentCtx = getCurrentContext();
+        if (parentCtx && parentCtx->type == RenderingContextType::TEMPLATE) {
+            auto& parentTemplateCtx = parentCtx->context.templateCtx;
+            // Invalidate shared buffer so parent refill starts fresh
+            bufferPos = 0;
+            bufferLen = 0;
+            bufferOffset = parentTemplateCtx.position;
+
+            // Clear cached buffer state stored on the parent template context
+            parentTemplateCtx.bufferPos = 0;
+            parentTemplateCtx.bufferLen = 0;
+            parentTemplateCtx.bufferOffset = parentTemplateCtx.position;
+        } else {
+            // No parent template context, reset buffer state
+            bufferPos = 0;
+            bufferLen = 0;
+            bufferOffset = 0;
+        }
+    } else {
+        // No more contexts, reset buffer state
+        bufferPos = 0;
+        bufferLen = 0;
+        bufferOffset = 0;
+    }
+    
+    // Clear the popped context
+    memset(&ctx, 0, sizeof(RenderingContext));
+}
+
+RenderingContext* DeviceFrameworkTemplateContext::getCurrentContext() {
+    if (renderingDepth == 0) return nullptr;
+    return &renderingStack[renderingDepth - 1];
+}
+
+RenderingContext* DeviceFrameworkTemplateContext::getContext(int depth) {
+    if (depth < 0 || depth >= renderingDepth) return nullptr;
+    return &renderingStack[depth];
+}
+
+bool DeviceFrameworkTemplateContext::isRenderingTemplate() const {
+    if (renderingDepth == 0) return false;
+    return renderingStack[renderingDepth - 1].type == RenderingContextType::TEMPLATE;
+}
+
+bool DeviceFrameworkTemplateContext::isRenderingPlaceholder() const {
+    if (renderingDepth == 0) return false;
+    RenderingContextType type = renderingStack[renderingDepth - 1].type;
+    return type == RenderingContextType::PLACEHOLDER_DATA || 
+           type == RenderingContextType::PLACEHOLDER_TEMPLATE;
+}
+
+RenderingContextType DeviceFrameworkTemplateContext::getCurrentContextType() const {
+    if (renderingDepth == 0) return RenderingContextType::TEMPLATE; // Default
+    return renderingStack[renderingDepth - 1].type;
+}
+
+bool DeviceFrameworkTemplateContext::isComplete() const {
+    return state == TemplateRenderState::COMPLETE || state == TemplateRenderState::ERROR;
+}
+
+bool DeviceFrameworkTemplateContext::hasError() const {
+    return state == TemplateRenderState::ERROR;
+}
+
+String DeviceFrameworkTemplateContext::getStateString() const {
+    switch (state) {
+        case TemplateRenderState::TEXT: return "TEXT";
+        case TemplateRenderState::BUILDING_PLACEHOLDER: return "BUILDING_PLACEHOLDER";
+        case TemplateRenderState::RENDERING_CONTEXT: return "RENDERING_CONTEXT";
+        case TemplateRenderState::COMPLETE: return "COMPLETE";
+        case TemplateRenderState::ERROR: return "ERROR";
+        default: return "UNKNOWN";
+    }
+}
+
+String DeviceFrameworkTemplateContext::getStackTrace() const {
+    String trace = "Stack trace (depth=" + String(renderingDepth) + "):\n";
+    for (int i = 0; i < renderingDepth; i++) {
+        const RenderingContext& ctx = renderingStack[i];
+        String typeStr;
+        switch (ctx.type) {
+            case RenderingContextType::TEMPLATE: typeStr = "TEMPLATE"; break;
+            case RenderingContextType::PLACEHOLDER_DATA: typeStr = "PLACEHOLDER_DATA"; break;
+            case RenderingContextType::PLACEHOLDER_TEMPLATE: typeStr = "PLACEHOLDER_TEMPLATE"; break;
+            default: typeStr = "UNKNOWN"; break;
+        }
+        trace += "  [" + String(i) + "] " + String(ctx.name) + " (type=" + typeStr + ")";
+        if (ctx.type == RenderingContextType::TEMPLATE) {
+            trace += " at pos " + String(ctx.context.templateCtx.position);
+        } else if (ctx.type == RenderingContextType::PLACEHOLDER_DATA) {
+            trace += " at offset " + String(ctx.context.data.offset);
+        }
+        trace += "\n";
+    }
+    return trace;
+}
+
+bool DeviceFrameworkTemplateContext::refillBuffer() {
+    RenderingContext* currentCtx = getCurrentContext();
+    if (!currentCtx || currentCtx->type != RenderingContextType::TEMPLATE) {
+        return false;
+    }
+    
+    auto& templateCtx = currentCtx->context.templateCtx;
+    if (templateCtx.position >= templateCtx.templateLen) {
+        return false;
+    }
+    
+    bufferLen = min(BUFFER_SIZE, templateCtx.templateLen - templateCtx.position);
+    
+    if (bufferLen > 0) {
+        if (templateCtx.isProgmem) {
+            memcpy_P(readBuffer, templateCtx.templateData + templateCtx.position, bufferLen);
+        } else {
+            memcpy(readBuffer, templateCtx.templateData + templateCtx.position, bufferLen);
+        }
+        bufferPos = 0;
+        bufferOffset = templateCtx.position;
+        // Save buffer state to template context
+        templateCtx.bufferPos = bufferPos;
+        templateCtx.bufferLen = bufferLen;
+        templateCtx.bufferOffset = bufferOffset;
+        // Don't advance templateCtx.position here - it will be updated as we read characters
+        return true;
+    }
+    
+    return false;
+}
+
+char DeviceFrameworkTemplateContext::getNextChar() {
+    RenderingContext* currentCtx = getCurrentContext();
+    if (!currentCtx || currentCtx->type != RenderingContextType::TEMPLATE) {
+        return '\0';
+    }
+    
+    // Restore buffer state from template context if needed
+    auto& templateCtx = currentCtx->context.templateCtx;
+    if (bufferPos == 0 && bufferLen == 0 && templateCtx.bufferLen > 0) {
+        // Buffer state might be stale, restore from context
+        bufferPos = templateCtx.bufferPos;
+        bufferLen = templateCtx.bufferLen;
+        bufferOffset = templateCtx.bufferOffset;
+    }
+    
+    if (bufferPos >= bufferLen) {
+        if (!refillBuffer()) {
+            return '\0';  // End of template
+        }
+    }
+    char c = readBuffer[bufferPos++];
+    // Update template position to reflect current position
+    templateCtx.position = bufferOffset + bufferPos;
+    // Save buffer state to template context
+    templateCtx.bufferPos = bufferPos;
+    templateCtx.bufferLen = bufferLen;
+    templateCtx.bufferOffset = bufferOffset;
+    return c;
+}
+
+size_t DeviceFrameworkTemplateContext::getAvailableBytes() const {
+    return bufferLen - bufferPos;
+}
+
+bool DeviceFrameworkTemplateContext::hasMoreData() const {
+    RenderingContext* currentCtx = const_cast<DeviceFrameworkTemplateContext*>(this)->getCurrentContext();
+    if (!currentCtx || currentCtx->type != RenderingContextType::TEMPLATE) {
+        return false;
+    }
+    const auto& templateCtx = currentCtx->context.templateCtx;
+    return templateCtx.position < templateCtx.templateLen || bufferPos < bufferLen;
+}
+
+void DeviceFrameworkTemplateContext::resetPlaceholder() {
+    placeholderPos = 0;
+    memset(placeholderName, 0, sizeof(placeholderName));
+}
+

src/DeviceFrameworkTemplateEngineDebug.cpp

@@ -0,0 +1,28 @@
+#include "DeviceFrameworkTemplateEngineDebug.h"
+
+// Global logger pointer - starts as nullptr (disabled by default)
+DeviceFrameworkTemplateEngineLogger* deviceFrameworkTemplateEngineLogger = nullptr;
+
+// ============================================================================
+// LOGGING CONFIGURATION IMPLEMENTATIONS
+// ============================================================================
+
+bool deviceFrameworkTemplateEngineEnableLogging(DeviceFrameworkTemplateEngineLogger* logger) {
+    if (logger == nullptr) {
+        return false;
+    }
+    deviceFrameworkTemplateEngineLogger = logger;
+    return true;
+}
+
+void deviceFrameworkTemplateEngineDisableLogging() {
+    deviceFrameworkTemplateEngineLogger = nullptr;
+}
+
+bool deviceFrameworkTemplateEngineIsLoggingEnabled() {
+    return deviceFrameworkTemplateEngineLogger != nullptr;
+}
+
+DeviceFrameworkTemplateEngineLogger* deviceFrameworkTemplateEngineGetLogger() {
+    return deviceFrameworkTemplateEngineLogger;
+}

src/DeviceFrameworkTemplateRenderer.cpp

@@ -0,0 +1,860 @@
+#include "DeviceFrameworkTemplateRenderer.h"
+#include "DeviceFrameworkTemplateEngineDebug.h"
+#include <pgmspace.h>
+#include <cstring>
+
+namespace {
+
+static bool pushPlaceholderEntry(DeviceFrameworkTemplateContext& ctx, const PlaceholderEntry* entry, const char* nameOverride = nullptr) {
+    if (entry == nullptr) {
+        DFTE_LOG_ERROR("Attempted to push null placeholder entry");
+        return false;
+    }
+
+    const char* name = nameOverride ? nameOverride : entry->name;
+
+    switch (entry->type) {
+        case PlaceholderType::PROGMEM_DATA:
+        case PlaceholderType::RAM_DATA: {
+            if (!ctx.pushContext(RenderingContextType::PLACEHOLDER_DATA, name)) {
+                return false;
+            }
+            RenderingContext* dataCtx = ctx.getCurrentContext();
+            dataCtx->context.data.entry = entry;
+            dataCtx->context.data.offset = 0;
+            return true;
+        }
+        case PlaceholderType::PROGMEM_TEMPLATE: {
+            if (!ctx.pushContext(RenderingContextType::PLACEHOLDER_TEMPLATE, name)) {
+                return false;
+            }
+            RenderingContext* placeholderCtx = ctx.getCurrentContext();
+            placeholderCtx->context.templatePlaceholder.entry = entry;
+
+            if (!ctx.pushContext(RenderingContextType::TEMPLATE, name)) {
+                ctx.popContext();
+                return false;
+            }
+
+            RenderingContext* templateCtx = ctx.getCurrentContext();
+            templateCtx->context.templateCtx.templateData = static_cast<const char*>(entry->data);
+            templateCtx->context.templateCtx.templateLen = entry->getLength(entry->data);
+            templateCtx->context.templateCtx.isProgmem = true;
+            templateCtx->context.templateCtx.position = 0;
+            templateCtx->context.templateCtx.iteratorPlaceholders = nullptr;
+            templateCtx->context.templateCtx.iteratorPlaceholderCount = 0;
+            return true;
+        }
+        case PlaceholderType::DYNAMIC_TEMPLATE: {
+            if (!ctx.pushContext(RenderingContextType::PLACEHOLDER_DYNAMIC_TEMPLATE, name)) {
+                return false;
+            }
+
+            RenderingContext* dynamicCtx = ctx.getCurrentContext();
+            dynamicCtx->context.dynamicTemplate.entry = entry;
+            dynamicCtx->context.dynamicTemplate.offset = 0;
+            dynamicCtx->context.dynamicTemplate.templateData = nullptr;
+            dynamicCtx->context.dynamicTemplate.templateLength = 0;
+
+            const DynamicTemplateDescriptor* descriptor = static_cast<const DynamicTemplateDescriptor*>(entry->data);
+            if (descriptor == nullptr || descriptor->getter == nullptr) {
+                DFTE_LOG_ERROR("Dynamic template placeholder missing descriptor: " + String(name));
+                ctx.popContext();
+                return false;
+            }
+
+            const char* templateData = descriptor->getter(descriptor->userData);
+            if (templateData == nullptr) {
+                DFTE_LOG_WARN("Dynamic template getter returned null for placeholder: " + String(name));
+                templateData = "";
+            }
+
+            size_t templateLen = DeviceFrameworkPlaceholderRegistry::getDynamicTemplateLength(descriptor, templateData);
+            dynamicCtx->context.dynamicTemplate.templateData = templateData;
+            dynamicCtx->context.dynamicTemplate.templateLength = templateLen;
+
+            if (!ctx.pushContext(RenderingContextType::TEMPLATE, name)) {
+                ctx.popContext();
+                return false;
+            }
+
+            RenderingContext* templateCtx = ctx.getCurrentContext();
+            templateCtx->context.templateCtx.templateData = templateData;
+            templateCtx->context.templateCtx.templateLen = templateLen;
+            templateCtx->context.templateCtx.isProgmem = false;
+            templateCtx->context.templateCtx.position = 0;
+            templateCtx->context.templateCtx.iteratorPlaceholders = nullptr;
+            templateCtx->context.templateCtx.iteratorPlaceholderCount = 0;
+            return true;
+        }
+        case PlaceholderType::CONDITIONAL: {
+            const ConditionalDescriptor* descriptor = static_cast<const ConditionalDescriptor*>(entry->data);
+            if (descriptor == nullptr || descriptor->evaluate == nullptr) {
+                DFTE_LOG_ERROR("Conditional placeholder missing descriptor: " + String(name));
+                return false;
+            }
+
+            if (!ctx.pushContext(RenderingContextType::PLACEHOLDER_CONDITIONAL, name)) {
+                return false;
+            }
+
+            RenderingContext* conditionalCtx = ctx.getCurrentContext();
+            conditionalCtx->context.conditional.entry = entry;
+            conditionalCtx->context.conditional.descriptor = descriptor;
+            conditionalCtx->context.conditional.branchResolved = false;
+            conditionalCtx->context.conditional.delegateName = nullptr;
+            conditionalCtx->context.conditional.delegateEntry = nullptr;
+
+            if (!ctx.registry) {
+                conditionalCtx->context.conditional.branchResolved = true;
+                return true;
+            }
+
+            ConditionalBranchResult branch = descriptor->evaluate(descriptor->userData);
+            const char* delegateName = nullptr;
+            switch (branch) {
+                case ConditionalBranchResult::TRUE_BRANCH:
+                    delegateName = descriptor->truePlaceholder;
+                    break;
+                case ConditionalBranchResult::FALSE_BRANCH:
+                    delegateName = descriptor->falsePlaceholder;
+                    break;
+                case ConditionalBranchResult::SKIP:
+                default:
+                    delegateName = nullptr;
+                    break;
+            }
+
+            conditionalCtx->context.conditional.branchResolved = true;
+            conditionalCtx->context.conditional.delegateName = delegateName;
+
+            if (delegateName == nullptr) {
+                return true;
+            }
+
+            const PlaceholderEntry* delegateEntry = ctx.registry->getPlaceholder(delegateName);
+            if (!delegateEntry) {
+                DFTE_LOG_WARN("Conditional placeholder '" + String(name) + "' referenced unknown placeholder: " + String(delegateName));
+                return true;
+            }
+
+            conditionalCtx->context.conditional.delegateEntry = delegateEntry;
+
+            if (!pushPlaceholderEntry(ctx, delegateEntry, delegateName)) {
+                ctx.popContext();
+                return false;
+            }
+
+            return true;
+        }
+        case PlaceholderType::ITERATOR: {
+            if (!ctx.pushContext(RenderingContextType::PLACEHOLDER_ITERATOR, name)) {
+                return false;
+            }
+
+            RenderingContext* iteratorCtx = ctx.getCurrentContext();
+            iteratorCtx->context.iterator.entry = entry;
+            iteratorCtx->context.iterator.descriptor = static_cast<const IteratorDescriptor*>(entry->data);
+            iteratorCtx->context.iterator.handle = nullptr;
+            iteratorCtx->context.iterator.initialized = false;
+            iteratorCtx->context.iterator.handleOpen = false;
+
+            const IteratorDescriptor* descriptor = iteratorCtx->context.iterator.descriptor;
+            if (!descriptor || !descriptor->next) {
+                DFTE_LOG_ERROR("Iterator placeholder missing descriptor: " + String(name));
+                ctx.popContext();
+                return false;
+            }
+
+            return true;
+        }
+        default:
+            DFTE_LOG_WARN("pushPlaceholderEntry does not support placeholder type for: " + String(name));
+            return false;
+    }
+}
+
+static DeviceFrameworkTemplateRenderer::RenderOutcome processIteratorContext(DeviceFrameworkTemplateContext& ctx, RenderingContext* iteratorCtx) {
+    if (!iteratorCtx) {
+        return DeviceFrameworkTemplateRenderer::makeError();
+    }
+
+    const IteratorDescriptor* descriptor = iteratorCtx->context.iterator.descriptor;
+    if (!descriptor || !descriptor->next) {
+        DFTE_LOG_ERROR("Iterator placeholder missing descriptor or next handler");
+        return DeviceFrameworkTemplateRenderer::makeError();
+    }
+
+    auto& iteratorState = iteratorCtx->context.iterator;
+
+    if (!iteratorState.initialized) {
+        iteratorState.handle = descriptor->open ? descriptor->open(descriptor->userData) : descriptor->userData;
+        iteratorState.initialized = true;
+        iteratorState.handleOpen = descriptor->close != nullptr && iteratorState.handle != nullptr && descriptor->open != nullptr;
+    }
+
+    IteratorItemView view = {};
+    IteratorStepResult step = descriptor->next(iteratorState.handle, view);
+
+    switch (step) {
+        case IteratorStepResult::ITEM_READY: {
+            if (!view.templateData && view.templateLength == 0) {
+                return DeviceFrameworkTemplateRenderer::makeState(TemplateRenderState::RENDERING_CONTEXT, true);
+            }
+
+            const char* templatePtr = view.templateData;
+            if (!templatePtr) {
+                return DeviceFrameworkTemplateRenderer::makeState(TemplateRenderState::RENDERING_CONTEXT, true);
+            }
+
+            size_t templateLen = view.templateLength;
+            if (templateLen == 0) {
+                templateLen = view.templateIsProgmem ? strlen_P(templatePtr) : strlen(templatePtr);
+            }
+
+            if (!ctx.pushContext(RenderingContextType::TEMPLATE, iteratorCtx->name)) {
+                return DeviceFrameworkTemplateRenderer::makeError();
+            }
+
+            RenderingContext* templateCtx = ctx.getCurrentContext();
+            templateCtx->context.templateCtx.templateData = templatePtr;
+            templateCtx->context.templateCtx.templateLen = templateLen;
+            templateCtx->context.templateCtx.isProgmem = view.templateIsProgmem;
+            templateCtx->context.templateCtx.position = 0;
+            templateCtx->context.templateCtx.iteratorPlaceholders = view.placeholders;
+            templateCtx->context.templateCtx.iteratorPlaceholderCount = view.placeholderCount;
+
+            return DeviceFrameworkTemplateRenderer::makeState(TemplateRenderState::TEXT, true);
+        }
+        case IteratorStepResult::COMPLETE: {
+            if (iteratorState.handleOpen && descriptor->close) {
+                descriptor->close(iteratorState.handle);
+                iteratorState.handleOpen = false;
+            }
+            iteratorState.handle = nullptr;
+
+            auto outcome = DeviceFrameworkTemplateRenderer::makeState(TemplateRenderState::RENDERING_CONTEXT, true);
+            outcome.popCount = 1;
+
+            RenderingContext* parent = (ctx.renderingDepth > 1) ? ctx.getContext(ctx.renderingDepth - 2) : nullptr;
+            if (!parent) {
+                outcome.nextState = TemplateRenderState::COMPLETE;
+                outcome.repeat = false;
+                outcome.finished = true;
+            } else if (parent->type == RenderingContextType::TEMPLATE) {
+                outcome.nextState = TemplateRenderState::TEXT;
+            }
+
+            return outcome;
+        }
+        case IteratorStepResult::ERROR:
+        default:
+            DFTE_LOG_ERROR("Iterator placeholder reported error");
+            if (descriptor->close && (iteratorState.handleOpen || iteratorState.handle != nullptr)) {
+                descriptor->close(iteratorState.handle);
+            }
+            iteratorState.handleOpen = false;
+            iteratorState.handle = nullptr;
+            return DeviceFrameworkTemplateRenderer::makeError();
+    }
+}
+
+} // namespace
+
+// Helper function to convert RenderingContextType to string
+static String getContextTypeString(RenderingContextType type) {
+    switch (type) {
+        case RenderingContextType::TEMPLATE: return "TEMPLATE";
+        case RenderingContextType::PLACEHOLDER_DATA: return "PLACEHOLDER_DATA";
+        case RenderingContextType::PLACEHOLDER_TEMPLATE: return "PLACEHOLDER_TEMPLATE";
+        default: return "UNKNOWN";
+    }
+}
+
+// Helper function to log state transitions with stack state
+static void logStateTransition(DeviceFrameworkTemplateContext& ctx, const String& fromState, const String& toState, const String& reason = "") {
+    if (!deviceFrameworkTemplateEngineLogger) {
+        return;
+    }
+
+    String msg = "State: " + fromState + " -> " + toState;
+    if (reason.length() > 0) {
+        msg += " (" + reason + ")";
+    }
+    msg += " | Stack depth: " + String(ctx.renderingDepth);
+    if (ctx.renderingDepth > 0) {
+        RenderingContext* currentCtx = ctx.getCurrentContext();
+        msg += " | Current: " + String(currentCtx->name) + " (type=" + getContextTypeString(currentCtx->type) + ")";
+    }
+    deviceFrameworkTemplateEngineLogger->debug(msg);
+}
+
+static String getStateName(TemplateRenderState state) {
+    switch (state) {
+        case TemplateRenderState::TEXT: return "TEXT";
+        case TemplateRenderState::BUILDING_PLACEHOLDER: return "BUILDING_PLACEHOLDER";
+        case TemplateRenderState::RENDERING_CONTEXT: return "RENDERING_CONTEXT";
+        case TemplateRenderState::COMPLETE: return "COMPLETE";
+        case TemplateRenderState::ERROR: return "ERROR";
+        default: return "UNKNOWN";
+    }
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::makeWritten(size_t bytes, TemplateRenderState state, bool repeat) {
+    return {bytes, state, repeat, false, false, 0, {false, RenderingContextType::TEMPLATE, nullptr}};
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::makeState(TemplateRenderState nextState, bool repeat) {
+    return {0, nextState, repeat, false, false, 0, {false, RenderingContextType::TEMPLATE, nullptr}};
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::makeComplete() {
+    return {0, TemplateRenderState::COMPLETE, false, true, false, 0, {false, RenderingContextType::TEMPLATE, nullptr}};
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::makeError() {
+    return {0, TemplateRenderState::ERROR, false, false, true, 0, {false, RenderingContextType::TEMPLATE, nullptr}};
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::renderChunk(DeviceFrameworkTemplateContext& ctx, uint8_t* buffer, size_t maxLen) {
+    RenderOutcome outcome = makeState(ctx.state, false);
+
+    switch (ctx.state) {
+        case TemplateRenderState::TEXT:
+            outcome = consumeTemplateText(ctx, buffer, maxLen);
+            break;
+        case TemplateRenderState::BUILDING_PLACEHOLDER:
+            outcome = buildPlaceholderToken(ctx);
+            break;
+        case TemplateRenderState::RENDERING_CONTEXT:
+            outcome = emitActiveContext(ctx, buffer, maxLen);
+            break;
+        case TemplateRenderState::COMPLETE:
+            return makeComplete();
+        case TemplateRenderState::ERROR:
+        default:
+            return makeError();
+    }
+
+    if (!applyStackCommands(ctx, outcome)) {
+        ctx.state = TemplateRenderState::ERROR;
+        return makeError();
+    }
+
+    TemplateRenderState previousState = ctx.state;
+    if (outcome.nextState != previousState) {
+        String fromState = getStateName(previousState);
+        ctx.state = outcome.nextState;
+        String toState = getStateName(ctx.state);
+        logStateTransition(ctx, fromState, toState);
+    } else {
+        ctx.state = outcome.nextState;
+    }
+
+    outcome.finished = (ctx.state == TemplateRenderState::COMPLETE);
+    outcome.errored = (ctx.state == TemplateRenderState::ERROR);
+
+    return outcome;
+}
+
+bool DeviceFrameworkTemplateRenderer::applyStackCommands(DeviceFrameworkTemplateContext& ctx, const RenderOutcome& outcome) {
+    for (uint8_t i = 0; i < outcome.popCount; ++i) {
+        if (ctx.renderingDepth == 0) {
+            DFTE_LOG_ERROR("Rendering stack underflow during pop");
+            return false;
+        }
+        ctx.popContext();
+    }
+
+    if (!outcome.pushContext.active) {
+        return true;
+    }
+
+    const PlaceholderEntry* entry = outcome.pushContext.entry;
+    if (entry == nullptr) {
+        DFTE_LOG_ERROR("Missing placeholder entry for pushContext");
+        return false;
+    }
+
+    const char* name = entry->name;
+
+    switch (outcome.pushContext.type) {
+        case RenderingContextType::PLACEHOLDER_DATA: {
+            if (!pushPlaceholderEntry(ctx, entry, name)) {
+                return false;
+            }
+            return true;
+        }
+        case RenderingContextType::PLACEHOLDER_TEMPLATE: {
+            if (!pushPlaceholderEntry(ctx, entry, name)) {
+                return false;
+            }
+            return true;
+        }
+        case RenderingContextType::PLACEHOLDER_DYNAMIC_TEMPLATE: {
+            if (!pushPlaceholderEntry(ctx, entry, name)) {
+                return false;
+            }
+            return true;
+        }
+        case RenderingContextType::PLACEHOLDER_CONDITIONAL: {
+            const ConditionalDescriptor* descriptor = static_cast<const ConditionalDescriptor*>(entry->data);
+            if (descriptor == nullptr || descriptor->evaluate == nullptr) {
+                DFTE_LOG_ERROR("Conditional placeholder missing descriptor: " + String(name));
+                return false;
+            }
+
+            ConditionalBranchResult branch = descriptor->evaluate(descriptor->userData);
+            const char* delegateName = nullptr;
+            switch (branch) {
+                case ConditionalBranchResult::TRUE_BRANCH:
+                    delegateName = descriptor->truePlaceholder;
+                    break;
+                case ConditionalBranchResult::FALSE_BRANCH:
+                    delegateName = descriptor->falsePlaceholder;
+                    break;
+                case ConditionalBranchResult::SKIP:
+                default:
+                    delegateName = nullptr;
+                    break;
+            }
+
+            if (delegateName == nullptr) {
+                return true; // Nothing to render
+            }
+
+            const PlaceholderEntry* delegateEntry = ctx.registry ? ctx.registry->getPlaceholder(delegateName) : nullptr;
+            if (!delegateEntry) {
+                DFTE_LOG_WARN("Conditional placeholder '" + String(name) + "' referenced unknown placeholder: " + String(delegateName));
+                return true;
+            }
+
+            if (!ctx.pushContext(RenderingContextType::PLACEHOLDER_CONDITIONAL, name)) {
+                return false;
+            }
+
+            RenderingContext* conditionalCtx = ctx.getCurrentContext();
+            conditionalCtx->context.conditional.entry = entry;
+            conditionalCtx->context.conditional.descriptor = descriptor;
+            conditionalCtx->context.conditional.branchResolved = true;
+            conditionalCtx->context.conditional.delegateName = delegateName;
+            conditionalCtx->context.conditional.delegateEntry = delegateEntry;
+
+            if (!pushPlaceholderEntry(ctx, delegateEntry, delegateName)) {
+                ctx.popContext();
+                return false;
+            }
+
+            return true;
+        }
+        case RenderingContextType::PLACEHOLDER_ITERATOR: {
+            if (!ctx.pushContext(RenderingContextType::PLACEHOLDER_ITERATOR, name)) {
+                return false;
+            }
+
+            RenderingContext* iteratorCtx = ctx.getCurrentContext();
+            iteratorCtx->context.iterator.entry = entry;
+            iteratorCtx->context.iterator.descriptor = static_cast<const IteratorDescriptor*>(entry->data);
+            iteratorCtx->context.iterator.handle = nullptr;
+            iteratorCtx->context.iterator.initialized = false;
+            iteratorCtx->context.iterator.handleOpen = false;
+
+            if (!iteratorCtx->context.iterator.descriptor || !iteratorCtx->context.iterator.descriptor->next) {
+                DFTE_LOG_ERROR("Iterator placeholder missing next handler: " + String(name));
+                ctx.popContext();
+                return false;
+            }
+
+            return true;
+        }
+        case RenderingContextType::TEMPLATE: {
+            if (!ctx.pushContext(RenderingContextType::TEMPLATE, name)) {
+                return false;
+            }
+            RenderingContext* templateCtx = ctx.getCurrentContext();
+            templateCtx->context.templateCtx.templateData = static_cast<const char*>(entry->data);
+            templateCtx->context.templateCtx.templateLen = entry->getLength(entry->data);
+            templateCtx->context.templateCtx.isProgmem = true;
+            templateCtx->context.templateCtx.position = 0;
+            templateCtx->context.templateCtx.iteratorPlaceholders = nullptr;
+            templateCtx->context.templateCtx.iteratorPlaceholderCount = 0;
+            return true;
+        }
+        default:
+            return true;
+    }
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::handleTemplateCompletion(DeviceFrameworkTemplateContext& ctx) {
+    RenderOutcome outcome = makeState(TemplateRenderState::TEXT, true);
+    outcome.popCount = 1;
+
+    if (ctx.renderingDepth <= 1) {
+        outcome.nextState = TemplateRenderState::COMPLETE;
+        outcome.repeat = false;
+        outcome.finished = true;
+        return outcome;
+    }
+
+    RenderingContext* parentCtx = ctx.getContext(ctx.renderingDepth - 2);
+    if (parentCtx && (parentCtx->type == RenderingContextType::PLACEHOLDER_TEMPLATE ||
+                      parentCtx->type == RenderingContextType::PLACEHOLDER_DYNAMIC_TEMPLATE ||
+                      parentCtx->type == RenderingContextType::PLACEHOLDER_CONDITIONAL)) {
+        outcome.popCount += 1;
+        if (ctx.renderingDepth > 2) {
+            parentCtx = ctx.getContext(ctx.renderingDepth - 3);
+        } else {
+            parentCtx = nullptr;
+        }
+    }
+
+    if (!parentCtx) {
+        outcome.nextState = TemplateRenderState::COMPLETE;
+        outcome.repeat = false;
+        outcome.finished = true;
+        return outcome;
+    }
+
+    if (parentCtx->type == RenderingContextType::TEMPLATE) {
+        outcome.nextState = TemplateRenderState::TEXT;
+    } else {
+        outcome.nextState = TemplateRenderState::RENDERING_CONTEXT;
+    }
+
+    outcome.repeat = true;
+    return outcome;
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::consumeTemplateText(DeviceFrameworkTemplateContext& ctx, uint8_t* buffer, size_t maxLen) {
+    RenderingContext* currentCtx = ctx.getCurrentContext();
+    if (!currentCtx || currentCtx->type != RenderingContextType::TEMPLATE) {
+        DFTE_LOG_ERROR("consumeTemplateText called without TEMPLATE context");
+        return makeError();
+    }
+
+    auto& templateCtx = currentCtx->context.templateCtx;
+
+    // Empty template completes immediately
+    if (templateCtx.templateLen == 0) {
+        return handleTemplateCompletion(ctx);
+    }
+
+    size_t written = 0;
+    while (written < maxLen) {
+        if (templateCtx.position >= templateCtx.templateLen) {
+            break;
+        }
+
+        char c = ctx.getNextChar();
+        if (c == '\0') {
+            break;
+        }
+
+        if (c == '%') {
+            ctx.placeholderPos = 0;
+            ctx.placeholderName[ctx.placeholderPos++] = '%';
+            RenderOutcome outcome = makeState(TemplateRenderState::BUILDING_PLACEHOLDER, true);
+            outcome.bytesWritten = written;
+            return outcome;
+        }
+
+        buffer[written++] = c;
+    }
+
+    if (written > 0) {
+        RenderOutcome outcome = makeWritten(written, TemplateRenderState::TEXT, written < maxLen);
+        if (written < maxLen) {
+            outcome.repeat = true;
+        }
+        return outcome;
+    }
+
+    // No bytes written, check if template finished
+    if (templateCtx.position >= templateCtx.templateLen || !ctx.hasMoreData()) {
+        return handleTemplateCompletion(ctx);
+    }
+
+    // Need more data
+    return makeState(TemplateRenderState::TEXT, false);
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::buildPlaceholderToken(DeviceFrameworkTemplateContext& ctx) {
+    RenderingContext* currentCtx = ctx.getCurrentContext();
+    if (!currentCtx || currentCtx->type != RenderingContextType::TEMPLATE) {
+        DFTE_LOG_ERROR("buildPlaceholderToken called without TEMPLATE context");
+        return makeError();
+    }
+
+    bool madeProgress = false;
+    while (ctx.placeholderPos < sizeof(ctx.placeholderName) - 1) {
+        if (!ctx.hasMoreData()) {
+            break;
+        }
+
+        char c = ctx.getNextChar();
+        if (c == '\0') {
+            break;
+        }
+
+        madeProgress = true;
+        ctx.placeholderName[ctx.placeholderPos++] = c;
+
+        if (c == '%') {
+            ctx.placeholderName[ctx.placeholderPos] = '\0';
+            return resolvePlaceholder(ctx);
+        }
+    }
+
+    if (ctx.placeholderPos >= sizeof(ctx.placeholderName) - 1) {
+        DFTE_LOG_WARN("Placeholder name too long: " + String(ctx.placeholderName));
+        ctx.resetPlaceholder();
+        return makeState(TemplateRenderState::TEXT, true);
+    }
+
+    if (!ctx.hasMoreData()) {
+        DFTE_LOG_WARN("Incomplete placeholder at end of template");
+        ctx.resetPlaceholder();
+        return handleTemplateCompletion(ctx);
+    }
+
+    // We consumed data but did not finish; stay in BUILDING_PLACEHOLDER
+    RenderOutcome outcome = makeState(TemplateRenderState::BUILDING_PLACEHOLDER, false);
+    outcome.repeat = madeProgress;
+    return outcome;
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::resolvePlaceholder(DeviceFrameworkTemplateContext& ctx) {
+    const PlaceholderEntry* entry = ctx.registry ? ctx.registry->getPlaceholder(ctx.placeholderName) : nullptr;
+
+    if (!entry) {
+        RenderingContext* currentCtx = ctx.getCurrentContext();
+        if (currentCtx && currentCtx->type == RenderingContextType::TEMPLATE) {
+            const PlaceholderEntry* overrides = currentCtx->context.templateCtx.iteratorPlaceholders;
+            size_t overrideCount = currentCtx->context.templateCtx.iteratorPlaceholderCount;
+            for (size_t i = 0; i < overrideCount; ++i) {
+                if (strcmp(overrides[i].name, ctx.placeholderName) == 0) {
+                    entry = &overrides[i];
+                    break;
+                }
+            }
+        }
+    }
+
+    if (!entry) {
+        DFTE_LOG_WARN("Unknown placeholder: " + String(ctx.placeholderName));
+        ctx.resetPlaceholder();
+        return makeState(TemplateRenderState::TEXT, true);
+    }
+
+    RenderOutcome outcome = makeState(TemplateRenderState::RENDERING_CONTEXT, true);
+    outcome.pushContext.active = true;
+
+    switch (entry->type) {
+        case PlaceholderType::PROGMEM_DATA:
+        case PlaceholderType::RAM_DATA:
+            outcome.pushContext.type = RenderingContextType::PLACEHOLDER_DATA;
+            outcome.pushContext.entry = entry;
+            break;
+        case PlaceholderType::PROGMEM_TEMPLATE:
+            outcome.pushContext.type = RenderingContextType::PLACEHOLDER_TEMPLATE;
+            outcome.pushContext.entry = entry;
+            outcome.nextState = TemplateRenderState::TEXT;
+            break;
+        case PlaceholderType::DYNAMIC_TEMPLATE:
+            outcome.pushContext.type = RenderingContextType::PLACEHOLDER_DYNAMIC_TEMPLATE;
+            outcome.pushContext.entry = entry;
+            outcome.nextState = TemplateRenderState::TEXT;
+            break;
+        case PlaceholderType::CONDITIONAL:
+            outcome.pushContext.type = RenderingContextType::PLACEHOLDER_CONDITIONAL;
+            outcome.pushContext.entry = entry;
+            outcome.nextState = TemplateRenderState::RENDERING_CONTEXT;
+            break;
+        case PlaceholderType::ITERATOR:
+            outcome.pushContext.type = RenderingContextType::PLACEHOLDER_ITERATOR;
+            outcome.pushContext.entry = entry;
+            outcome.nextState = TemplateRenderState::RENDERING_CONTEXT;
+            break;
+        default:
+            DFTE_LOG_WARN("Unsupported placeholder type");
+            ctx.resetPlaceholder();
+            return makeState(TemplateRenderState::TEXT, true);
+    }
+
+    ctx.resetPlaceholder();
+    return outcome;
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::emitActiveContext(DeviceFrameworkTemplateContext& ctx, uint8_t* buffer, size_t maxLen) {
+    RenderingContext* currentCtx = ctx.getCurrentContext();
+    if (!currentCtx) {
+        return makeComplete();
+    }
+
+    switch (currentCtx->type) {
+        case RenderingContextType::TEMPLATE:
+            return consumeTemplateText(ctx, buffer, maxLen);
+
+        case RenderingContextType::PLACEHOLDER_DATA:
+            return streamPlaceholderData(ctx, currentCtx, buffer, maxLen);
+
+        case RenderingContextType::PLACEHOLDER_TEMPLATE:
+            return makeState(TemplateRenderState::TEXT, true);
+
+        case RenderingContextType::PLACEHOLDER_DYNAMIC_TEMPLATE:
+            return makeState(TemplateRenderState::TEXT, true);
+
+        case RenderingContextType::PLACEHOLDER_CONDITIONAL:
+            return makeState(TemplateRenderState::RENDERING_CONTEXT, true);
+
+        case RenderingContextType::PLACEHOLDER_ITERATOR:
+            return processIteratorContext(ctx, currentCtx);
+
+        default:
+            DFTE_LOG_ERROR("emitActiveContext encountered unknown context type");
+            return makeError();
+    }
+}
+
+DeviceFrameworkTemplateRenderer::RenderOutcome DeviceFrameworkTemplateRenderer::streamPlaceholderData(DeviceFrameworkTemplateContext& ctx,
+                                                                                                     RenderingContext* context,
+                                                                                                     uint8_t* buffer,
+                                                                                                     size_t maxLen) {
+    auto& dataCtx = context->context.data;
+    const PlaceholderEntry* entry = dataCtx.entry;
+
+    if (!entry) {
+        DFTE_LOG_ERROR("Placeholder data context missing entry");
+        RenderOutcome outcome = makeState(TemplateRenderState::RENDERING_CONTEXT, true);
+        outcome.popCount = 1;
+        return outcome;
+    }
+
+    if (ctx.registry == nullptr) {
+        DFTE_LOG_ERROR("Placeholder registry not set; cannot render placeholder: " + String(entry->name));
+        RenderOutcome outcome = makeState(TemplateRenderState::RENDERING_CONTEXT, true);
+        outcome.popCount = 1;
+
+        RenderingContext* parent = (ctx.renderingDepth > 1) ? ctx.getContext(ctx.renderingDepth - 2) : nullptr;
+        if (!parent) {
+            outcome.nextState = TemplateRenderState::COMPLETE;
+            outcome.repeat = false;
+            outcome.finished = true;
+        } else if (parent->type == RenderingContextType::TEMPLATE) {
+            outcome.nextState = TemplateRenderState::TEXT;
+        }
+
+        return outcome;
+    }
+
+    size_t totalLength = entry->getLength(entry->data);
+    if (dataCtx.offset >= totalLength) {
+        RenderOutcome outcome = makeState(TemplateRenderState::RENDERING_CONTEXT, true);
+        outcome.popCount = 1;
+
+        RenderingContext* parent = (ctx.renderingDepth > 1) ? ctx.getContext(ctx.renderingDepth - 2) : nullptr;
+        if (parent && parent->type == RenderingContextType::PLACEHOLDER_CONDITIONAL) {
+            outcome.popCount += 1;
+            parent = (ctx.renderingDepth > 2) ? ctx.getContext(ctx.renderingDepth - 3) : nullptr;
+        }
+        if (!parent) {
+            outcome.nextState = TemplateRenderState::COMPLETE;
+            outcome.repeat = false;
+            outcome.finished = true;
+        } else if (parent->type == RenderingContextType::TEMPLATE) {
+            outcome.nextState = TemplateRenderState::TEXT;
+        }
+        return outcome;
+    }
+
+    size_t written = ctx.registry->renderPlaceholder(entry, dataCtx.offset, buffer, maxLen);
+    if (written > 0) {
+        dataCtx.offset += written;
+        return makeWritten(written, TemplateRenderState::RENDERING_CONTEXT, written < maxLen);
+    }
+
+    // No bytes written; treat as completion and pop context
+    RenderOutcome outcome = makeState(TemplateRenderState::RENDERING_CONTEXT, true);
+    outcome.popCount = 1;
+
+    RenderingContext* parent = (ctx.renderingDepth > 1) ? ctx.getContext(ctx.renderingDepth - 2) : nullptr;
+    if (parent && parent->type == RenderingContextType::PLACEHOLDER_CONDITIONAL) {
+        outcome.popCount += 1;
+        parent = (ctx.renderingDepth > 2) ? ctx.getContext(ctx.renderingDepth - 3) : nullptr;
+    }
+    if (!parent) {
+        outcome.nextState = TemplateRenderState::COMPLETE;
+        outcome.repeat = false;
+        outcome.finished = true;
+    } else if (parent->type == RenderingContextType::TEMPLATE) {
+        outcome.nextState = TemplateRenderState::TEXT;
+    }
+
+    return outcome;
+}
+size_t DeviceFrameworkTemplateRenderer::renderNextChunk(DeviceFrameworkTemplateContext& ctx, uint8_t* buffer, size_t maxLen) {
+    if (ctx.isComplete() || ctx.hasError()) {
+        return 0;
+    }
+
+    size_t written = 0;
+    size_t iterations = 0;
+    uint8_t* writePtr = buffer;
+    size_t remaining = maxLen;
+
+    while (remaining > 0 && !ctx.isComplete() && !ctx.hasError() && iterations < MAX_ITERATIONS) {
+        RenderOutcome outcome = renderChunk(ctx, writePtr, remaining);
+
+        written += outcome.bytesWritten;
+        ctx.totalBytesProcessed += outcome.bytesWritten;
+        writePtr += outcome.bytesWritten;
+        remaining -= outcome.bytesWritten;
+        iterations++;
+
+        if (outcome.finished || outcome.errored) {
+            break;
+        }
+
+        if (!outcome.repeat && outcome.bytesWritten == 0) {
+            break;
+        }
+    }
+
+    if (iterations >= MAX_ITERATIONS) {
+        DFTE_LOG_WARN("Maximum iterations reached in renderNextChunk");
+    }
+
+    return written;
+}
+
+void DeviceFrameworkTemplateRenderer::initializeContext(DeviceFrameworkTemplateContext& ctx, const char* templateData) {
+    initializeContext(ctx, templateData, true);
+}
+
+void DeviceFrameworkTemplateRenderer::initializeContext(DeviceFrameworkTemplateContext& ctx, const char* templateData, bool templateInProgmem) {
+    ctx.reset();
+    
+    // Push initial template context
+    if (!ctx.pushContext(RenderingContextType::TEMPLATE, "ROOT")) {
+        ctx.state = TemplateRenderState::ERROR;
+        return;
+    }
+    
+    RenderingContext* rootCtx = ctx.getCurrentContext();
+    rootCtx->context.templateCtx.templateData = templateData;
+    rootCtx->context.templateCtx.templateLen = templateInProgmem ? strlen_P(templateData) : strlen(templateData);
+    rootCtx->context.templateCtx.isProgmem = templateInProgmem;
+    rootCtx->context.templateCtx.position = 0;
+    
+    ctx.state = TemplateRenderState::TEXT;
+    logStateTransition(ctx, "INIT", "TEXT", "Initialized template context");
+}
+
+bool DeviceFrameworkTemplateRenderer::isComplete(const DeviceFrameworkTemplateContext& ctx) {
+    return ctx.isComplete();
+}
+
+bool DeviceFrameworkTemplateRenderer::hasError(const DeviceFrameworkTemplateContext& ctx) {
+    return ctx.hasError();
+}
+

test/test_template_engine/templates/edge_case_templates.h

@@ -0,0 +1,66 @@
+#ifndef EDGE_CASE_TEMPLATES_H
+#define EDGE_CASE_TEMPLATES_H
+
+#include <Arduino.h>
+
+// Incomplete placeholder (no closing %)
+const char PROGMEM incomplete_placeholder_template[] = "Text with % incomplete";
+
+// Placeholder with only %
+const char PROGMEM empty_placeholder_template[] = "Text with %% text";
+
+// Placeholder with % in text (not a placeholder)
+const char PROGMEM percent_in_text_template[] = "Text with 50% discount";
+
+// Special characters
+const char PROGMEM special_chars_template[] = "Line1\nLine2\tTabbed\r\nWindows";
+
+// Template with only placeholders (no text)
+const char PROGMEM only_placeholders_template[] = "%A%%B%%C%";
+
+// Template with newlines and placeholders
+const char PROGMEM newlines_template[] = 
+    "Line 1\n"
+    "%PLACEHOLDER%\n"
+    "Line 3\n";
+
+// Template with tabs and placeholders
+const char PROGMEM tabs_template[] = 
+    "Column1\tColumn2\t%PLACEHOLDER%\tColumn4";
+
+// Template with mixed whitespace
+const char PROGMEM whitespace_template[] = 
+    "  Leading spaces\n"
+    "%PLACEHOLDER%\n"
+    "Trailing spaces  ";
+
+// Template with unicode-like characters (if supported)
+const char PROGMEM unicode_template[] = 
+    "Test: %PLACEHOLDER% with special chars: ©®™";
+
+// Template with very long placeholder name (at max length)
+const char PROGMEM max_length_placeholder_template[] = "%VERY_LONG_PLACEHOLDER_NAME%";
+
+// Template with placeholder name that might exceed max
+const char PROGMEM over_length_placeholder_template[] = "%THIS_PLACEHOLDER_NAME_IS_TOO_LONG_FOR_BUFFER%";
+
+// Template with multiple incomplete placeholders
+const char PROGMEM multiple_incomplete_template[] = 
+    "Text with % incomplete and % another incomplete";
+
+// Template with placeholder at very end
+const char PROGMEM placeholder_at_end_template[] = "Text%END%";
+
+// Template with placeholder at very start
+const char PROGMEM placeholder_at_start_template[] = "%START%Text";
+
+// Template with only text (no placeholders)
+const char PROGMEM only_text_template[] = 
+    "This is a template with only text and no placeholders at all.";
+
+// Template with escaped-like patterns (not actual escaping, just patterns)
+const char PROGMEM escaped_patterns_template[] = 
+    "Text with %% and %PLACEHOLDER% and %%";
+
+#endif // EDGE_CASE_TEMPLATES_H
+

test/test_template_engine/templates/nested_templates.h

@@ -0,0 +1,163 @@
+#ifndef NESTED_TEMPLATES_H
+#define NESTED_TEMPLATES_H
+
+#include <Arduino.h>
+
+// One level nesting
+const char PROGMEM nested_one_level_outer[] = "Outer: %INNER%";
+const char PROGMEM nested_one_level_inner[] = "Inner content";
+
+// Two levels nesting
+const char PROGMEM nested_two_levels_outer[] = "Level1: %LEVEL2%";
+const char PROGMEM nested_two_levels_mid[] = "Level2: %LEVEL3%";
+const char PROGMEM nested_two_levels_inner[] = "Level3 content";
+
+// Three levels nesting
+const char PROGMEM nested_three_levels_outer[] = "Outer: %MID%";
+const char PROGMEM nested_three_levels_mid[] = "Mid: %INNER%";
+const char PROGMEM nested_three_levels_inner[] = "Inner: %DEEP%";
+const char PROGMEM nested_three_levels_deep[] = "Deep content";
+
+// Four levels nesting
+const char PROGMEM nested_four_levels_outer[] = "L1: %L2%";
+const char PROGMEM nested_four_levels_level2[] = "L2: %L3%";
+const char PROGMEM nested_four_levels_level3[] = "L3: %L4%";
+const char PROGMEM nested_four_levels_level4[] = "L4 content";
+
+// Large web-style templates to simulate WebInterface-sized payloads (intentionally fuzzed)
+const char PROGMEM simulated_web_outer[] = R"rawliteral(
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <title>%TITLE%</title>
+    <style>%STYLES%</style>
+</head>
+<body data-theme="%THEME%">
+    <section id="app-shell">
+        %HEADER%
+        <div class="app-layout">
+            %SIDEBAR%
+            <main class="app-main">
+                %CONTENT%
+            </main>
+        </div>
+        %FOOTER%
+    </section>
+    <script defer>%SCRIPTS%</script>
+</body>
+</html>
+)rawliteral";
+
+const char PROGMEM simulated_web_header[] = R"rawliteral(
+<header class="app-header">
+    <div class="branding">
+        <img src="data:image/webp;base64,%LOGO_BASE64%" alt="Elixir" class="branding-logo">
+        <div class="branding-copy">
+            <h1>%TITLE%</h1>
+            <p class="tagline">Powering ambient devices</p>
+        </div>
+    </div>
+    %NAV%
+</header>
+)rawliteral";
+
+const char PROGMEM simulated_web_nav[] = R"rawliteral(
+<nav class="app-nav">
+    <ul>
+        <li><a href="#overview" class="nav-link">Overview</a></li>
+        <li><a href="#telemetry" class="nav-link">Telemetry</a></li>
+        <li><a href="#actions" class="nav-link">Actions</a></li>
+    </ul>
+</nav>
+)rawliteral";
+
+const char PROGMEM simulated_web_sidebar[] = R"rawliteral(
+<aside class="app-sidebar">
+    <h2>Quick Metrics</h2>
+    <ul>
+        <li>WiFi RSSI: <span id="metric-rssi">%RSSI%</span>dBm</li>
+        <li>Heap Free: <span id="metric-heap">%HEAP%</span> bytes</li>
+        <li>Uptime: <span id="metric-uptime">%UPTIME%</span></li>
+    </ul>
+</aside>
+)rawliteral";
+
+const char PROGMEM simulated_web_content[] = R"rawliteral(
+<section id="overview" class="panel">
+    <h2>Device Overview</h2>
+    <p id="device-summary">Preparing device snapshot...</p>
+</section>
+<section id="telemetry" class="panel">
+    <h2>Telemetry</h2>
+    <div class="telemetry-grid">
+        <div class="telemetry-card">
+            <h3>Network</h3>
+            <p>SSID: <span id="wifi-ssid">pending</span></p>
+            <p>IP: <span id="wifi-ip">pending</span></p>
+        </div>
+        <div class="telemetry-card">
+            <h3>MQTT</h3>
+            <p>Status: <span id="mqtt-status">pending</span></p>
+            <p>Broker: <span id="mqtt-broker">pending</span></p>
+        </div>
+        <div class="telemetry-card">
+            <h3>Sensors</h3>
+            <p>Temperature: <span id="sensor-temp">--</span></p>
+            <p>Humidity: <span id="sensor-humidity">--</span></p>
+        </div>
+    </div>
+</section>
+<section id="actions" class="panel">
+    <h2>Automation Actions</h2>
+    <button class="btn" onclick="queueAction('restart')">Restart</button>
+    <button class="btn" onclick="queueAction('factory-reset')">Factory Reset</button>
+</section>
+)rawliteral";
+
+const char PROGMEM simulated_web_footer[] = R"rawliteral(
+<footer class="app-footer">
+    <small>&copy; 2024 Elixir DeviceFramework Labs</small>
+</footer>
+)rawliteral";
+
+const char PROGMEM simulated_web_scripts[] = R"rawliteral(
+function queueAction(action) {
+    window.dispatchEvent(new CustomEvent('device-action', { detail: action }));
+}
+window.addEventListener('load', () => {
+    document.body.dataset.ready = 'true';
+});
+)rawliteral";
+
+// Nested template with placeholders
+const char PROGMEM nested_with_placeholder_outer[] = "Outer: %NESTED%";
+const char PROGMEM nested_with_placeholder_inner[] = "Inner: %PLACEHOLDER%";
+
+// Nested template with multiple placeholders
+const char PROGMEM nested_multi_outer[] = "%HEADER%\n%CONTENT%\n%FOOTER%";
+const char PROGMEM nested_multi_header[] = "<header>%TITLE%</header>";
+const char PROGMEM nested_multi_content[] = "<main>%BODY%</main>";
+const char PROGMEM nested_multi_footer[] = "<footer>Footer</footer>";
+
+// Deep nesting for stack depth testing
+const char PROGMEM deep_nest_level1[] = "L1: %L2%";
+const char PROGMEM deep_nest_level2[] = "L2: %L3%";
+const char PROGMEM deep_nest_level3[] = "L3: %L4%";
+const char PROGMEM deep_nest_level4[] = "L4: %L5%";
+const char PROGMEM deep_nest_level5[] = "L5: %L6%";
+const char PROGMEM deep_nest_level6[] = "L6: %L7%";
+const char PROGMEM deep_nest_level7[] = "L7: %L8%";
+const char PROGMEM deep_nest_level8[] = "L8: %L9%";
+const char PROGMEM deep_nest_level9[] = "L9: %L10%";
+const char PROGMEM deep_nest_level10[] = "L10: %L11%";
+const char PROGMEM deep_nest_level11[] = "L11: %L12%";
+const char PROGMEM deep_nest_level12[] = "L12: %L13%";
+const char PROGMEM deep_nest_level13[] = "L13: %L14%";
+const char PROGMEM deep_nest_level14[] = "L14: %L15%";
+const char PROGMEM deep_nest_level15[] = "L15: %L16%";
+const char PROGMEM deep_nest_level16[] = "L16: content";
+
+#endif // NESTED_TEMPLATES_H
+

test/test_template_engine/templates/placeholder_templates.h

@@ -0,0 +1,38 @@
+#ifndef PLACEHOLDER_TEMPLATES_H
+#define PLACEHOLDER_TEMPLATES_H
+
+#include <Arduino.h>
+
+// PROGMEM_DATA placeholder
+const char PROGMEM progmem_data_template[] = "CSS: %STYLES%";
+
+// PROGMEM_TEMPLATE placeholder
+const char PROGMEM nested_template_template[] = "Header: %HEADER%";
+
+// RAM_DATA placeholder
+const char PROGMEM ram_data_template[] = "Title: %PAGE_TITLE%";
+
+// Mixed placeholders
+const char PROGMEM mixed_placeholders_template[] = 
+    "%HEADER%\nTitle: %PAGE_TITLE%\n%STYLES%\n%FOOTER%";
+
+// Multiple PROGMEM_DATA placeholders
+const char PROGMEM multiple_progmem_template[] = 
+    "%CSS%\n%JS%\n%FAVICON%";
+
+// Multiple RAM_DATA placeholders
+const char PROGMEM multiple_ram_template[] = 
+    "Title: %TITLE%\nSubtitle: %SUBTITLE%\nDescription: %DESC%";
+
+// Test data for PROGMEM placeholders
+const char PROGMEM test_css_data[] = "body { color: red; }";
+const char PROGMEM test_js_data[] = "console.log('test');";
+const char PROGMEM test_favicon_data[] = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+
+// Test templates for nested templates
+const char PROGMEM test_header_template[] = "<header>%LOGO%</header>";
+const char PROGMEM test_footer_template[] = "<footer>Footer</footer>";
+const char PROGMEM test_logo_template[] = "<img src=\"%LOGO_URL%\">";
+
+#endif // PLACEHOLDER_TEMPLATES_H
+

test/test_template_engine/templates/simple_templates.h

@@ -0,0 +1,35 @@
+#ifndef SIMPLE_TEMPLATES_H
+#define SIMPLE_TEMPLATES_H
+
+#include <Arduino.h>
+
+// Empty template
+const char PROGMEM empty_template[] = "";
+
+// Plain text template
+const char PROGMEM plain_text_template[] = "Hello, World!";
+
+// Single placeholder
+const char PROGMEM single_placeholder_template[] = "Hello, %NAME%!";
+
+// Multiple placeholders
+const char PROGMEM multiple_placeholders_template[] = 
+    "Title: %TITLE%\nContent: %CONTENT%\nFooter: %FOOTER%";
+
+// Placeholder at start
+const char PROGMEM placeholder_start_template[] = "%PLACEHOLDER% text";
+
+// Placeholder at end
+const char PROGMEM placeholder_end_template[] = "text %PLACEHOLDER%";
+
+// Consecutive placeholders
+const char PROGMEM consecutive_placeholders_template[] = "%A%%B%%C%";
+
+// Long text between placeholders
+const char PROGMEM long_text_template[] = 
+    "This is a very long text that should test buffer refill logic. "
+    "It contains many characters and should span multiple buffer fills. "
+    "%PLACEHOLDER% More text here.";
+
+#endif // SIMPLE_TEMPLATES_H
+

test/test_template_engine/test_main.cpp

@@ -0,0 +1,139 @@
+#include <unity.h>
+#include <Arduino.h>
+#include <TemplateEngine.h>
+#include "test_main.h"
+#include "utils/test_utils.h"
+#include "DeviceFrameworkTemplateEngineDebug.h"
+
+// Logger implementation for tests - uses Serial.println
+class TestTemplateEngineLogger : public DeviceFrameworkTemplateEngineLogger {
+public:
+    void error(const String& msg) override {
+        Serial.print("[DFTE ERROR] ");
+        Serial.println(msg);
+    }
+    
+    void warn(const String& msg) override {
+        Serial.print("[DFTE WARN] ");
+        Serial.println(msg);
+    }
+    
+    void info(const String& msg) override {
+        Serial.print("[DFTE INFO] ");
+        Serial.println(msg);
+    }
+    
+    void debug(const String& msg) override {
+        Serial.print("[DFTE DEBUG] ");
+        Serial.println(msg);
+    }
+};
+
+// Global logger instance
+TestTemplateEngineLogger testLogger;
+
+// Test case array
+TestCase tests[] = {
+    // Group 1: PlaceholderRegistry Tests
+    TEST_ENTRY(test_placeholder_registry_registration),
+    TEST_ENTRY(test_placeholder_registry_lookup),
+    TEST_ENTRY(test_placeholder_registry_rendering),
+    TEST_ENTRY(test_placeholder_registry_edge_cases),
+    
+    // Group 2: TemplateContext Tests
+    TEST_ENTRY(test_template_context_initialization),
+    TEST_ENTRY(test_template_context_stack),
+    TEST_ENTRY(test_template_context_buffer),
+    TEST_ENTRY(test_template_context_state),
+    
+    // Group 3: TemplateRenderer Tests
+    TEST_ENTRY(test_template_renderer_basic),
+    TEST_ENTRY(test_template_renderer_chunked),
+    TEST_ENTRY(test_template_renderer_state_transitions),
+    TEST_ENTRY(test_template_renderer_placeholders),
+    TEST_ENTRY(test_template_renderer_nested),
+    TEST_ENTRY(test_template_renderer_nested_four_levels),
+    TEST_ENTRY(test_template_renderer_nested_chunk_progress),
+    TEST_ENTRY(test_template_renderer_large_templates),
+    TEST_ENTRY(test_template_renderer_parallel_contexts),
+    TEST_ENTRY(test_template_renderer_root_ram_template),
+    TEST_ENTRY(test_template_renderer_missing_registry),
+    TEST_ENTRY(test_template_renderer_dynamic_basic),
+    TEST_ENTRY(test_template_renderer_dynamic_empty),
+    TEST_ENTRY(test_template_renderer_dynamic_mutable),
+    TEST_ENTRY(test_template_renderer_conditional_true_branch),
+    TEST_ENTRY(test_template_renderer_conditional_false_branch),
+    TEST_ENTRY(test_template_renderer_conditional_skip),
+    TEST_ENTRY(test_template_renderer_conditional_missing_delegate),
+    TEST_ENTRY(test_template_renderer_conditional_nested_iterator),
+    TEST_ENTRY(test_template_renderer_iterator_basic),
+    TEST_ENTRY(test_template_renderer_iterator_empty),
+    TEST_ENTRY(test_template_renderer_iterator_dynamic_items),
+    TEST_ENTRY(test_template_renderer_iterator_error_cleanup),
+    
+    // Group 4: Integration Tests
+    TEST_ENTRY(test_integration_full_rendering),
+    TEST_ENTRY(test_integration_memory_efficiency),
+    TEST_ENTRY(test_integration_multiple_templates),
+    
+    // Group 5: Edge Cases
+    TEST_ENTRY(test_edge_cases_error_handling),
+    TEST_ENTRY(test_edge_cases_boundary_conditions),
+    TEST_ENTRY(test_edge_cases_stress),
+};
+
+const size_t TEST_COUNT = sizeof(tests) / sizeof(TestCase);
+
+// Test state variables
+size_t next_index = 0;
+bool begun = false;
+
+// Test setup and teardown
+void setUp(void) {
+    // No per-test setup needed
+}
+
+void tearDown(void) {
+    // No per-test teardown needed
+}
+
+// Arduino setup and loop functions (required by framework)
+void setup() {
+    Serial.begin(115200);
+    delay(2000); // Give time for serial to initialize
+    
+    Serial.println("\n[TEST] =============================================");
+    Serial.println("[TEST] === DeviceFrameworkTemplateEngine Test Setup ===");
+    Serial.println("[TEST] Starting template engine tests...");
+    Serial.println("[TEST] =============================================");
+    
+    // Enable template engine debug logging
+    deviceFrameworkTemplateEngineEnableLogging(&testLogger);
+    Serial.println("[TEST] Template engine debug logging enabled");
+    
+    UNITY_BEGIN(); // Start Unity test framework
+    begun = true; // Start tests immediately
+}
+
+void loop() {
+    // Run one test and return immediately
+    if (begun && next_index < TEST_COUNT) {
+        TestCase& t = tests[next_index];
+        Serial.print("\n[TEST] ==== Running test: ");
+        Serial.print(t.name);
+        Serial.println(" ====");
+        UnityDefaultTestRun(t.fn, t.name, t.line);
+        next_index++;
+        return; // yield quickly
+    }
+    
+    // All tests completed
+    if (begun && next_index >= TEST_COUNT) {
+        Serial.println("\n[TEST] =============================================");
+        Serial.println("[TEST] === All tests completed ===");
+        Serial.println("[TEST] =============================================");
+        UNITY_END(); // prints Unity summary
+        begun = false; // avoid repeating
+    }
+}
+

test/test_template_engine/test_main.h

@@ -0,0 +1,56 @@
+#ifndef TEST_MAIN_H
+#define TEST_MAIN_H
+
+#include <Arduino.h>
+#include "utils/test_utils.h"
+
+// Test function declarations
+// Group 1: PlaceholderRegistry Tests
+void test_placeholder_registry_registration();
+void test_placeholder_registry_lookup();
+void test_placeholder_registry_rendering();
+void test_placeholder_registry_edge_cases();
+
+// Group 2: TemplateContext Tests
+void test_template_context_initialization();
+void test_template_context_stack();
+void test_template_context_buffer();
+void test_template_context_state();
+
+// Group 3: TemplateRenderer Tests
+void test_template_renderer_basic();
+void test_template_renderer_chunked();
+void test_template_renderer_state_transitions();
+void test_template_renderer_placeholders();
+void test_template_renderer_nested();
+void test_template_renderer_nested_four_levels();
+void test_template_renderer_nested_chunk_progress();
+void test_template_renderer_large_templates();
+void test_template_renderer_parallel_contexts();
+void test_template_renderer_root_ram_template();
+void test_template_renderer_missing_registry();
+void test_template_renderer_dynamic_basic();
+void test_template_renderer_dynamic_empty();
+void test_template_renderer_dynamic_mutable();
+void test_template_renderer_conditional_true_branch();
+void test_template_renderer_conditional_false_branch();
+void test_template_renderer_conditional_skip();
+void test_template_renderer_conditional_missing_delegate();
+void test_template_renderer_conditional_nested_iterator();
+void test_template_renderer_iterator_basic();
+void test_template_renderer_iterator_empty();
+void test_template_renderer_iterator_dynamic_items();
+void test_template_renderer_iterator_error_cleanup();
+
+// Group 4: Integration Tests
+void test_integration_full_rendering();
+void test_integration_memory_efficiency();
+void test_integration_multiple_templates();
+
+// Group 5: Edge Cases
+void test_edge_cases_error_handling();
+void test_edge_cases_boundary_conditions();
+void test_edge_cases_stress();
+
+#endif // TEST_MAIN_H
+

test/test_template_engine/tests/test_edge_cases.cpp

@@ -0,0 +1,307 @@
+#include <unity.h>
+#include <Arduino.h>
+#include <TemplateEngine.h>
+#include "../templates/simple_templates.h"
+#include "../templates/placeholder_templates.h"
+#include "../templates/edge_case_templates.h"
+#include "../templates/nested_templates.h"
+#include "../utils/test_utils.h"
+
+// Test RAM data getter that returns null
+static const char* getNullRamData() {
+    return nullptr;
+}
+
+// Test RAM data getter that returns empty string
+static const char* getEmptyRamData() {
+    static String empty = "";
+    return empty.c_str();
+}
+
+// Test error handling
+void test_edge_cases_error_handling() {
+    Serial.println("[TEST]   Testing error handling...");
+    
+    PlaceholderRegistry registry(10);
+    TemplateContext ctx;
+    ctx.setRegistry(&registry);
+    
+    // Test render with null template pointer (should handle gracefully)
+    // Note: initializeContext expects valid PROGMEM pointer, so we'll test with empty template
+    TemplateRenderer::initializeContext(ctx, empty_template);
+    String result1 = captureRenderedOutput(ctx);
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("", result1.c_str(), 
+        "Should handle empty template");
+    
+    // Test render with null registry
+    ctx.reset();
+    ctx.setRegistry(nullptr);
+    TemplateRenderer::initializeContext(ctx, single_placeholder_template);
+    String result2 = captureRenderedOutput(ctx);
+    // Should skip placeholder and render text
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("Hello, !", result2.c_str(), 
+        "Should handle null registry");
+    
+    // Test RAM getter returning null
+    registry.registerRamData("%NULL%", getNullRamData);
+    ctx.reset();
+    TemplateRenderer::initializeContext(ctx, single_placeholder_template);
+    ctx.setRegistry(&registry);
+    String result3 = captureRenderedOutput(ctx);
+    // Should handle null return gracefully
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete even with null RAM getter");
+    
+    // Test RAM getter returning empty string
+    registry.registerRamData("%EMPTY%", getEmptyRamData);
+    ctx.reset();
+    TemplateRenderer::initializeContext(ctx, single_placeholder_template);
+    ctx.setRegistry(&registry);
+    String result4 = captureRenderedOutput(ctx);
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete with empty RAM data");
+    
+    // Test incomplete placeholder (no closing %)
+    ctx.reset();
+    TemplateRenderer::initializeContext(ctx, incomplete_placeholder_template);
+    ctx.setRegistry(&registry);
+    String result5 = captureRenderedOutput(ctx);
+    // Should handle incomplete placeholder gracefully
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete even with incomplete placeholder");
+    
+    Serial.println("[TEST]   Error handling tests completed successfully");
+}
+
+// Test boundary conditions
+void test_edge_cases_boundary_conditions() {
+    Serial.println("[TEST]   Testing boundary conditions...");
+    
+    PlaceholderRegistry registry(10);
+    registry.registerProgmemData("%PLACEHOLDER%", test_css_data);
+    
+    TemplateContext ctx;
+    ctx.setRegistry(&registry);
+    
+    // Test placeholder at start
+    // PLACEHOLDER is already registered above, so we can use it
+    Serial.print("[DEBUG] Edge case - %PLACEHOLDER% registered: ");
+    Serial.println(registry.getPlaceholder("%PLACEHOLDER%") != nullptr ? "YES" : "NO");
+    ctx.reset();
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, placeholder_start_template);
+    Serial.print("[DEBUG] Edge case template: [");
+    Serial.print(placeholder_start_template);
+    Serial.println("]");
+    String result1 = captureRenderedOutput(ctx);
+    Serial.print("[DEBUG] Edge case result length: ");
+    Serial.println(result1.length());
+    Serial.print("[DEBUG] Edge case result: [");
+    Serial.print(result1);
+    Serial.println("]");
+    Serial.print("[DEBUG] Edge case - Contains ' text': ");
+    Serial.println(result1.indexOf(" text") >= 0 ? "YES" : "NO");
+    Serial.print("[DEBUG] Edge case - Contains 'body': ");
+    Serial.println(result1.indexOf("body") >= 0 ? "YES" : "NO");
+    Serial.print("[DEBUG] Edge case - Final state: ");
+    Serial.println(ctx.getStateString());
+    RenderingContext* currentCtx = ctx.getCurrentContext();
+    if (currentCtx && currentCtx->type == RenderingContextType::TEMPLATE) {
+        Serial.print("[DEBUG] Edge case - Template length: ");
+        Serial.println(currentCtx->context.templateCtx.templateLen);
+    }
+    // Should render placeholder and text
+    TEST_ASSERT_TRUE_MESSAGE(result1.length() > 0, "Should handle placeholder at start");
+    // Check for either the placeholder content or the text part
+    TEST_ASSERT_TRUE_MESSAGE(result1.indexOf(" text") >= 0 || result1.indexOf("body") >= 0, 
+        "Should contain placeholder or text");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete with placeholder at start");
+    
+    // Test placeholder at end
+    ctx.reset();
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, placeholder_end_template);
+    String result2 = captureRenderedOutput(ctx);
+    TEST_ASSERT_TRUE_MESSAGE(result2.length() > 0, "Should handle placeholder at end");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete with placeholder at end");
+    
+    // Test only placeholders (no text)
+    registry.registerProgmemData("%A%", test_css_data);
+    registry.registerProgmemData("%B%", test_js_data);
+    registry.registerProgmemData("%C%", test_favicon_data);
+    ctx.reset();
+    TemplateRenderer::initializeContext(ctx, only_placeholders_template);
+    ctx.setRegistry(&registry);
+    String result3 = captureRenderedOutput(ctx);
+    TEST_ASSERT_TRUE_MESSAGE(result3.length() > 0, "Should handle only placeholders");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete with only placeholders");
+    
+    // Test only text (no placeholders)
+    ctx.reset();
+    TemplateRenderer::initializeContext(ctx, only_text_template);
+    ctx.setRegistry(&registry);
+    String result4 = captureRenderedOutput(ctx);
+    TEST_ASSERT_TRUE_MESSAGE(result4.length() > 0, "Should handle only text");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete with only text");
+    
+    // Test special characters
+    ctx.reset();
+    TemplateRenderer::initializeContext(ctx, special_chars_template);
+    ctx.setRegistry(&registry);
+    String result5 = captureRenderedOutput(ctx);
+    TEST_ASSERT_TRUE_MESSAGE(result5.length() > 0, "Should handle special characters");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete with special characters");
+    
+    // Test newlines and placeholders
+    ctx.reset();
+    TemplateRenderer::initializeContext(ctx, newlines_template);
+    ctx.setRegistry(&registry);
+    String result6 = captureRenderedOutput(ctx);
+    TEST_ASSERT_TRUE_MESSAGE(result6.length() > 0, "Should handle newlines");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete with newlines");
+    
+    // Test empty placeholder (%%)
+    ctx.reset();
+    TemplateRenderer::initializeContext(ctx, empty_placeholder_template);
+    ctx.setRegistry(&registry);
+    String result7 = captureRenderedOutput(ctx);
+    // Should handle empty placeholder gracefully
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete with empty placeholder");
+    
+    Serial.println("[TEST]   Boundary condition tests completed successfully");
+}
+
+// Test stress conditions
+void test_edge_cases_stress() {
+    Serial.println("[TEST]   Testing stress conditions...");
+    
+    PlaceholderRegistry registry(50);
+    
+    // Register many placeholders
+    for (int i = 0; i < 20; i++) {
+        char name[10];
+        sprintf(name, "%%P%d%%", i);
+        registry.registerProgmemData(name, test_css_data);
+    }
+    
+    TEST_ASSERT_EQUAL_MESSAGE(20, registry.getCount(), 
+        "Should register many placeholders");
+    
+    // Test template with many placeholders
+    // Note: PROGMEM templates must be defined at file scope
+    const char many_placeholders_template[] = 
+        "%P0%%P1%%P2%%P3%%P4%%P5%%P6%%P7%%P8%%P9%"
+        "%P10%%P11%%P12%%P13%%P14%%P15%%P16%%P17%%P18%%P19%";
+    
+    // All placeholders are already registered above
+    Serial.print("[DEBUG] Stress test - Registry count: ");
+    Serial.println(registry.getCount());
+    Serial.print("[DEBUG] Stress test - %P0% registered: ");
+    Serial.println(registry.getPlaceholder("%P0%") != nullptr ? "YES" : "NO");
+    Serial.print("[DEBUG] Stress test - %P19% registered: ");
+    Serial.println(registry.getPlaceholder("%P19%") != nullptr ? "YES" : "NO");
+    TemplateContext ctx;
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, many_placeholders_template);
+    Serial.print("[DEBUG] Stress test template length: ");
+    RenderingContext* currentCtx = ctx.getCurrentContext();
+    if (currentCtx && currentCtx->type == RenderingContextType::TEMPLATE) {
+        Serial.println(currentCtx->context.templateCtx.templateLen);
+    } else {
+        Serial.println(0);
+    }
+    String result = captureRenderedOutput(ctx);
+    Serial.print("[DEBUG] Stress test result length: ");
+    Serial.println(result.length());
+    Serial.print("[DEBUG] Stress test result (first 200 chars): [");
+    if (result.length() > 200) {
+        Serial.print(result.substring(0, 200));
+        Serial.println("...]");
+    } else {
+        Serial.print(result);
+        Serial.println("]");
+    }
+    Serial.print("[DEBUG] Stress test - Contains 'body': ");
+    Serial.println(result.indexOf("body") >= 0 ? "YES" : "NO");
+    Serial.print("[DEBUG] Stress test - Final state: ");
+    Serial.println(ctx.getStateString());
+    Serial.print("[DEBUG] Stress test - Is complete: ");
+    Serial.println(TemplateRenderer::isComplete(ctx) ? "YES" : "NO");
+    // All placeholders are registered with test_css_data, so result should contain "body" multiple times
+    TEST_ASSERT_TRUE_MESSAGE(result.length() > 0, "Should render template with many placeholders");
+    // Verify we got some content (all placeholders render the same CSS data)
+    TEST_ASSERT_TRUE_MESSAGE(result.indexOf("body") >= 0 || result.length() > 20, 
+        "Should contain rendered placeholder data");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete with many placeholders");
+    
+    // Test very long template
+    // Register placeholder for long_text_template (if not already registered)
+    if (registry.getPlaceholder("%PLACEHOLDER%") == nullptr) {
+        registry.registerProgmemData("%PLACEHOLDER%", test_css_data);
+    }
+    ctx.reset();
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, long_text_template);
+    String result2 = captureRenderedOutput(ctx);
+    
+    TEST_ASSERT_TRUE_MESSAGE(result2.length() > 0, "Should render very long template");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete very long template");
+    
+    // Test rendering with very small buffer repeatedly
+    ctx.reset();
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, long_text_template);
+    
+    uint8_t tinyBuffer[1];
+    int iterations = 0;
+    while (!TemplateRenderer::isComplete(ctx) && iterations < 10000) {
+        TemplateRenderer::renderNextChunk(ctx, tinyBuffer, sizeof(tinyBuffer));
+        iterations++;
+    }
+    
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete even with tiny buffer");
+    TEST_ASSERT_LESS_THAN_MESSAGE(10000, iterations, 
+        "Should complete in reasonable iterations");
+    
+    // Test stack depth near limit
+    registry.clear();
+    registry.registerProgmemTemplate("%L2%", deep_nest_level2);
+    registry.registerProgmemTemplate("%L3%", deep_nest_level3);
+    registry.registerProgmemTemplate("%L4%", deep_nest_level4);
+    registry.registerProgmemTemplate("%L5%", deep_nest_level5);
+    registry.registerProgmemTemplate("%L6%", deep_nest_level6);
+    registry.registerProgmemTemplate("%L7%", deep_nest_level7);
+    registry.registerProgmemTemplate("%L8%", deep_nest_level8);
+    registry.registerProgmemTemplate("%L9%", deep_nest_level9);
+    registry.registerProgmemTemplate("%L10%", deep_nest_level10);
+    registry.registerProgmemTemplate("%L11%", deep_nest_level11);
+    registry.registerProgmemTemplate("%L12%", deep_nest_level12);
+    registry.registerProgmemTemplate("%L13%", deep_nest_level13);
+    registry.registerProgmemTemplate("%L14%", deep_nest_level14);
+    registry.registerProgmemTemplate("%L15%", deep_nest_level15);
+    registry.registerProgmemTemplate("%L16%", deep_nest_level16);
+    
+    ctx.reset();
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, deep_nest_level1);
+    String result3 = captureRenderedOutput(ctx);
+    
+    TEST_ASSERT_TRUE_MESSAGE(result3.length() > 0, "Should render deep nested template");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should complete deep nested template");
+    TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(TemplateContext::MAX_RENDERING_DEPTH, ctx.renderingDepth, 
+        "Rendering depth should not exceed MAX_RENDERING_DEPTH");
+    
+    Serial.println("[TEST]   Stress condition tests completed successfully");
+}
+

test/test_template_engine/tests/test_integration.cpp

@@ -0,0 +1,198 @@
+#include <unity.h>
+#include <Arduino.h>
+#include <TemplateEngine.h>
+#include "../templates/simple_templates.h"
+#include "../templates/placeholder_templates.h"
+#include "../templates/nested_templates.h"
+#include "../utils/test_utils.h"
+
+// Test RAM data getters
+static String testTitle = "Test Title";
+static String testSubtitle = "Test Subtitle";
+static String testDesc = "Test Description";
+
+static const char* getTestTitle() { return testTitle.c_str(); }
+static const char* getTestSubtitle() { return testSubtitle.c_str(); }
+static const char* getTestDesc() { return testDesc.c_str(); }
+
+// Test full rendering scenarios
+void test_integration_full_rendering() {
+    Serial.println("[TEST]   Testing full rendering scenarios...");
+    
+    PlaceholderRegistry registry(20);
+    
+    // Register all placeholder types
+    // Note: mixed_placeholders_template uses %STYLES%, %PAGE_TITLE%, %HEADER%, %FOOTER%
+    registry.registerProgmemData("%STYLES%", test_css_data);
+    registry.registerProgmemData("%JS%", test_js_data);
+    registry.registerProgmemData("%FAVICON%", test_favicon_data);
+    registry.registerProgmemTemplate("%HEADER%", test_header_template);
+    registry.registerProgmemTemplate("%FOOTER%", test_footer_template);
+    registry.registerRamData("%PAGE_TITLE%", getTestTitle);
+    registry.registerRamData("%SUBTITLE%", getTestSubtitle);
+    registry.registerRamData("%DESC%", getTestDesc);
+    
+    TemplateContext ctx;
+    ctx.setRegistry(&registry);
+    Serial.print("[DEBUG] Registry count: ");
+    Serial.println(registry.getCount());
+    Serial.print("[DEBUG] %STYLES% registered: ");
+    Serial.println(registry.getPlaceholder("%STYLES%") != nullptr ? "YES" : "NO");
+    Serial.print("[DEBUG] %PAGE_TITLE% registered: ");
+    Serial.println(registry.getPlaceholder("%PAGE_TITLE%") != nullptr ? "YES" : "NO");
+    Serial.print("[DEBUG] %HEADER% registered: ");
+    Serial.println(registry.getPlaceholder("%HEADER%") != nullptr ? "YES" : "NO");
+    Serial.print("[DEBUG] %FOOTER% registered: ");
+    Serial.println(registry.getPlaceholder("%FOOTER%") != nullptr ? "YES" : "NO");
+    TemplateRenderer::initializeContext(ctx, mixed_placeholders_template);
+    String result = captureRenderedOutput(ctx);
+    Serial.print("[DEBUG] Mixed result length: ");
+    Serial.println(result.length());
+    Serial.print("[DEBUG] Mixed result: [");
+    Serial.print(result);
+    Serial.println("]");
+    Serial.print("[DEBUG] Contains 'Header:': ");
+    Serial.println(result.indexOf("Header:") >= 0 ? "YES" : "NO");
+    Serial.print("[DEBUG] Contains 'header': ");
+    Serial.println(result.indexOf("header") >= 0 ? "YES" : "NO");
+    Serial.print("[DEBUG] Contains 'body': ");
+    Serial.println(result.indexOf("body") >= 0 ? "YES" : "NO");
+    Serial.print("[DEBUG] Contains 'Title:': ");
+    Serial.println(result.indexOf("Title:") >= 0 ? "YES" : "NO");
+    TEST_ASSERT_TRUE_MESSAGE(result.length() > 0, "Should render template with all placeholder types");
+    // Check for rendered content - PROGMEM data is "body { color: red; }"
+    TEST_ASSERT_TRUE_MESSAGE(result.indexOf("Header:") >= 0 || result.indexOf("header") >= 0 || result.indexOf("body") >= 0 || result.indexOf("Title:") >= 0, 
+        "Should contain rendered content");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should be complete after rendering");
+    
+    // Test real-world HTML-like template structure
+    // Note: PROGMEM templates must be defined at file scope, not as local variables
+    // Using a simple template string instead
+    // Register placeholders for HTML template
+    registry.registerRamData("%TITLE%", getTestTitle);
+    registry.registerProgmemData("%CSS%", test_css_data);
+    
+    const char html_template[] = 
+        "<!DOCTYPE html>\n"
+        "<html>\n"
+        "<head>\n"
+        "  <title>%TITLE%</title>\n"
+        "  <style>%CSS%</style>\n"
+        "</head>\n"
+        "<body>\n"
+        "  %HEADER%\n"
+        "  <main>%DESC%</main>\n"
+        "  %FOOTER%\n"
+        "  <script>%JS%</script>\n"
+        "</body>\n"
+        "</html>";
+    
+    ctx.reset();
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, html_template);
+    String htmlResult = captureRenderedOutput(ctx);
+    
+    TEST_ASSERT_TRUE_MESSAGE(htmlResult.length() > 0, "Should render HTML-like template");
+    TEST_ASSERT_TRUE_MESSAGE(htmlResult.indexOf("<!DOCTYPE html>") >= 0, 
+        "Should contain HTML structure");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Should be complete after rendering HTML template");
+    
+    Serial.println("[TEST]   Full rendering scenario tests completed successfully");
+}
+
+// Test memory efficiency
+void test_integration_memory_efficiency() {
+    Serial.println("[TEST]   Testing memory efficiency...");
+    
+    PlaceholderRegistry registry(10);
+    // Register placeholder for long_text_template
+    registry.registerProgmemData("%PLACEHOLDER%", test_css_data);
+    
+    TemplateContext ctx;
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, long_text_template);
+    
+    size_t totalBytes = 0;
+    uint8_t buffer[64];
+    
+    while (!TemplateRenderer::isComplete(ctx)) {
+        size_t written = TemplateRenderer::renderNextChunk(ctx, buffer, sizeof(buffer));
+        totalBytes += written;
+        
+        // Verify buffer size stays reasonable
+        TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(sizeof(buffer), written, 
+            "Chunk size should not exceed buffer size");
+    }
+    
+    // Verify we processed all data
+    TEST_ASSERT_GREATER_THAN_MESSAGE(0, totalBytes, "Should process some bytes");
+    
+    // Test that stack depth stays within limits
+    ctx.reset();
+    TemplateRenderer::initializeContext(ctx, nested_one_level_outer);
+    ctx.setRegistry(&registry);
+    registry.registerProgmemTemplate("%INNER%", nested_one_level_inner);
+    
+    while (!TemplateRenderer::isComplete(ctx)) {
+        TemplateRenderer::renderNextChunk(ctx, buffer, sizeof(buffer));
+        TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(TemplateContext::MAX_RENDERING_DEPTH, ctx.renderingDepth, 
+            "Rendering depth should not exceed MAX_RENDERING_DEPTH");
+    }
+    
+    Serial.println("[TEST]   Memory efficiency tests completed successfully");
+}
+
+// Test multiple templates sequentially
+void test_integration_multiple_templates() {
+    Serial.println("[TEST]   Testing multiple templates sequentially...");
+    
+    PlaceholderRegistry registry(10);
+    registry.registerProgmemData("%CSS%", test_css_data);
+    registry.registerRamData("%TITLE%", getTestTitle);
+    
+    TemplateContext ctx;
+    ctx.setRegistry(&registry);
+    
+    // Register placeholder for progmem_data_template
+    registry.registerProgmemData("%STYLES%", test_css_data);
+    // Render first template
+    ctx.reset();
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, progmem_data_template);
+    String result1 = captureRenderedOutput(ctx);
+    TEST_ASSERT_TRUE_MESSAGE(result1.length() > 0, "Should render first template");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "First template should be complete");
+    
+    // Register placeholder for ram_data_template
+    registry.registerRamData("%PAGE_TITLE%", getTestTitle);
+    // Reset and render second template
+    ctx.reset();
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, ram_data_template);
+    String result2 = captureRenderedOutput(ctx);
+    TEST_ASSERT_TRUE_MESSAGE(result2.length() > 0, "Should render second template");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Second template should be complete");
+    
+    // Reset and render third template
+    ctx.reset();
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, plain_text_template);
+    String result3 = captureRenderedOutput(ctx);
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("Hello, World!", result3.c_str(), 
+        "Should render third template");
+    TEST_ASSERT_TRUE_MESSAGE(TemplateRenderer::isComplete(ctx), 
+        "Third template should be complete");
+    
+    // Verify results are different
+    TEST_ASSERT_NOT_EQUAL_MESSAGE(result1.c_str(), result2.c_str(), 
+        "Results should be different for different templates");
+    TEST_ASSERT_NOT_EQUAL_MESSAGE(result2.c_str(), result3.c_str(), 
+        "Results should be different for different templates");
+    
+    Serial.println("[TEST]   Multiple templates sequential tests completed successfully");
+}
+

test/test_template_engine/tests/test_placeholder_registry.cpp

@@ -0,0 +1,255 @@
+#include <unity.h>
+#include <Arduino.h>
+#include <TemplateEngine.h>
+#include "../templates/placeholder_templates.h"
+#include "../utils/test_utils.h"
+#include <pgmspace.h>
+
+// Note: PROGMEM data is defined in placeholder_templates.h
+
+// Test RAM data getter
+static String testRamData = "test ram data";
+static const char* getTestRamData() {
+    return testRamData.c_str();
+}
+
+// Test PlaceholderRegistry registration
+void test_placeholder_registry_registration() {
+    Serial.println("[TEST]   Testing PlaceholderRegistry registration...");
+    
+    PlaceholderRegistry registry(10);
+    
+    // Test initial state
+    TEST_ASSERT_EQUAL_MESSAGE(0, registry.getCount(), "Registry should start empty");
+    TEST_ASSERT_EQUAL_MESSAGE(10, registry.getMaxPlaceholders(), "Registry should have correct max");
+    
+    // Test register PROGMEM_DATA
+    TEST_ASSERT_TRUE_MESSAGE(registry.registerProgmemData("%TEST%", test_css_data), 
+        "Should register PROGMEM_DATA placeholder");
+    TEST_ASSERT_EQUAL_MESSAGE(1, registry.getCount(), "Registry count should be 1");
+    
+    // Test register PROGMEM_TEMPLATE
+    TEST_ASSERT_TRUE_MESSAGE(registry.registerProgmemTemplate("%HEADER%", test_header_template), 
+        "Should register PROGMEM_TEMPLATE placeholder");
+    TEST_ASSERT_EQUAL_MESSAGE(2, registry.getCount(), "Registry count should be 2");
+    
+    // Test register RAM_DATA
+    TEST_ASSERT_TRUE_MESSAGE(registry.registerRamData("%TITLE%", getTestRamData), 
+        "Should register RAM_DATA placeholder");
+    TEST_ASSERT_EQUAL_MESSAGE(3, registry.getCount(), "Registry count should be 3");
+    
+    // Test register multiple placeholders
+    TEST_ASSERT_TRUE_MESSAGE(registry.registerProgmemData("%CSS%", test_css_data), 
+        "Should register multiple PROGMEM_DATA placeholders");
+    TEST_ASSERT_TRUE_MESSAGE(registry.registerProgmemData("%JS%", test_js_data), 
+        "Should register multiple PROGMEM_DATA placeholders");
+    TEST_ASSERT_EQUAL_MESSAGE(5, registry.getCount(), "Registry count should be 5");
+    
+    // Test register duplicate (should warn but succeed)
+    TEST_ASSERT_TRUE_MESSAGE(registry.registerProgmemData("%TEST%", test_js_data), 
+        "Should allow duplicate registration (last wins)");
+    TEST_ASSERT_EQUAL_MESSAGE(6, registry.getCount(), "Registry count should be 6");
+    
+    // Test register with invalid name (null)
+    TEST_ASSERT_FALSE_MESSAGE(registry.registerProgmemData(nullptr, test_css_data), 
+        "Should reject null placeholder name");
+    
+    // Test register with invalid name (empty)
+    // Note: Empty string "" might be accepted by validation (length 0 is valid)
+    // The validation checks for null and length >= MAX_PLACEHOLDER_NAME_SIZE
+    // Empty string has length 0, which is < MAX_PLACEHOLDER_NAME_SIZE, so it might pass
+    // This test verifies the behavior - if empty strings are accepted, that's fine
+    const char* emptyStr = "";
+    bool emptyResult = registry.registerProgmemData(emptyStr, test_css_data);
+    // Empty string might be accepted (length 0 < MAX_PLACEHOLDER_NAME_SIZE)
+    // We just verify the function doesn't crash
+    (void)emptyResult; // Suppress unused variable warning
+    
+    // Test clear
+    registry.clear();
+    TEST_ASSERT_EQUAL_MESSAGE(0, registry.getCount(), "Registry should be empty after clear");
+    
+    // Test register when full
+    PlaceholderRegistry smallRegistry(2);
+    TEST_ASSERT_TRUE_MESSAGE(smallRegistry.registerProgmemData("%A%", test_css_data), 
+        "Should register first placeholder");
+    TEST_ASSERT_TRUE_MESSAGE(smallRegistry.registerProgmemData("%B%", test_js_data), 
+        "Should register second placeholder");
+    TEST_ASSERT_FALSE_MESSAGE(smallRegistry.registerProgmemData("%C%", test_css_data), 
+        "Should reject registration when registry is full");
+    
+    Serial.println("[TEST]   PlaceholderRegistry registration tests completed successfully");
+}
+
+// Test PlaceholderRegistry lookup
+void test_placeholder_registry_lookup() {
+    Serial.println("[TEST]   Testing PlaceholderRegistry lookup...");
+    
+    PlaceholderRegistry registry(10);
+    
+    // Register some placeholders
+    registry.registerProgmemData("%CSS%", test_css_data);
+    registry.registerProgmemTemplate("%HEADER%", test_header_template);
+    registry.registerRamData("%TITLE%", getTestRamData);
+    
+    // Test get existing placeholder
+    const PlaceholderEntry* entry1 = registry.getPlaceholder("%CSS%");
+    TEST_ASSERT_NOT_NULL_MESSAGE(entry1, "Should find existing PROGMEM_DATA placeholder");
+    TEST_ASSERT_EQUAL_MESSAGE(PlaceholderType::PROGMEM_DATA, entry1->type, 
+        "Placeholder type should be PROGMEM_DATA");
+    
+    const PlaceholderEntry* entry2 = registry.getPlaceholder("%HEADER%");
+    TEST_ASSERT_NOT_NULL_MESSAGE(entry2, "Should find existing PROGMEM_TEMPLATE placeholder");
+    TEST_ASSERT_EQUAL_MESSAGE(PlaceholderType::PROGMEM_TEMPLATE, entry2->type, 
+        "Placeholder type should be PROGMEM_TEMPLATE");
+    
+    const PlaceholderEntry* entry3 = registry.getPlaceholder("%TITLE%");
+    TEST_ASSERT_NOT_NULL_MESSAGE(entry3, "Should find existing RAM_DATA placeholder");
+    TEST_ASSERT_EQUAL_MESSAGE(PlaceholderType::RAM_DATA, entry3->type, 
+        "Placeholder type should be RAM_DATA");
+    
+    // Test get non-existent placeholder
+    const PlaceholderEntry* entry4 = registry.getPlaceholder("%NOTFOUND%");
+    TEST_ASSERT_NULL_MESSAGE(entry4, "Should return nullptr for non-existent placeholder");
+    
+    // Test case-sensitive matching
+    const PlaceholderEntry* entry5 = registry.getPlaceholder("%css%");
+    TEST_ASSERT_NULL_MESSAGE(entry5, "Should be case-sensitive (lowercase not found)");
+    
+    // Test get with null name
+    const PlaceholderEntry* entry6 = registry.getPlaceholder(nullptr);
+    TEST_ASSERT_NULL_MESSAGE(entry6, "Should return nullptr for null name");
+    
+    Serial.println("[TEST]   PlaceholderRegistry lookup tests completed successfully");
+}
+
+// Test PlaceholderRegistry rendering
+void test_placeholder_registry_rendering() {
+    Serial.println("[TEST]   Testing PlaceholderRegistry rendering...");
+    
+    PlaceholderRegistry registry(10);
+    
+    // Register PROGMEM_DATA placeholder
+    registry.registerProgmemData("%CSS%", test_css_data);
+    const PlaceholderEntry* entry1 = registry.getPlaceholder("%CSS%");
+    TEST_ASSERT_NOT_NULL_MESSAGE(entry1, "Should find PROGMEM_DATA placeholder");
+    
+    // Test render PROGMEM_DATA (full)
+    uint8_t buffer1[256];
+    size_t len1 = registry.renderPlaceholder(entry1, 0, buffer1, sizeof(buffer1));
+    char* temp1 = new char[len1 + 1];
+    memcpy(temp1, buffer1, len1);
+    temp1[len1] = '\0';
+    String result1 = String(temp1);
+    delete[] temp1;
+    
+    // Compare with PROGMEM data using strlen_P
+    size_t expectedLen = strlen_P(test_css_data);
+    TEST_ASSERT_EQUAL_MESSAGE(expectedLen, len1, 
+        "Should render full PROGMEM_DATA length");
+    // Compare first few characters to verify content
+    char firstChar = pgm_read_byte(test_css_data);
+    TEST_ASSERT_EQUAL_MESSAGE(firstChar, result1.charAt(0), 
+        "Should render correct PROGMEM_DATA content");
+    
+    // Test render PROGMEM_DATA (chunked)
+    uint8_t buffer2[10];
+    size_t len2 = registry.renderPlaceholder(entry1, 0, buffer2, sizeof(buffer2));
+    TEST_ASSERT_EQUAL_MESSAGE(10, len2, "Should render chunk of PROGMEM_DATA");
+    
+    // Test render PROGMEM_DATA with offset
+    size_t len3 = registry.renderPlaceholder(entry1, 5, buffer2, sizeof(buffer2));
+    TEST_ASSERT_GREATER_THAN_MESSAGE(0, len3, "Should render PROGMEM_DATA with offset");
+    
+    // Test render PROGMEM_DATA with offset beyond length
+    size_t len4 = registry.renderPlaceholder(entry1, 1000, buffer2, sizeof(buffer2));
+    TEST_ASSERT_EQUAL_MESSAGE(0, len4, "Should return 0 when offset beyond length");
+    
+    // Register RAM_DATA placeholder
+    registry.registerRamData("%TITLE%", getTestRamData);
+    const PlaceholderEntry* entry2 = registry.getPlaceholder("%TITLE%");
+    TEST_ASSERT_NOT_NULL_MESSAGE(entry2, "Should find RAM_DATA placeholder");
+    
+    // Test render RAM_DATA (full)
+    uint8_t buffer3[256];
+    size_t len5 = registry.renderPlaceholder(entry2, 0, buffer3, sizeof(buffer3));
+    char* temp2 = new char[len5 + 1];
+    memcpy(temp2, buffer3, len5);
+    temp2[len5] = '\0';
+    String result2 = String(temp2);
+    delete[] temp2;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE(testRamData.c_str(), result2.c_str(), 
+        "Should render full RAM_DATA");
+    
+    // Test render RAM_DATA (chunked)
+    uint8_t buffer4[5];
+    size_t len6 = registry.renderPlaceholder(entry2, 0, buffer4, sizeof(buffer4));
+    TEST_ASSERT_EQUAL_MESSAGE(5, len6, "Should render chunk of RAM_DATA");
+    
+    // Test render with null entry
+    size_t len7 = registry.renderPlaceholder(nullptr, 0, buffer1, sizeof(buffer1));
+    TEST_ASSERT_EQUAL_MESSAGE(0, len7, "Should return 0 for null entry");
+    
+    // Test render with maxLen = 0
+    size_t len8 = registry.renderPlaceholder(entry1, 0, buffer1, 0);
+    TEST_ASSERT_EQUAL_MESSAGE(0, len8, "Should return 0 when maxLen is 0");
+    
+    Serial.println("[TEST]   PlaceholderRegistry rendering tests completed successfully");
+}
+
+// Test PlaceholderRegistry edge cases
+void test_placeholder_registry_edge_cases() {
+    Serial.println("[TEST]   Testing PlaceholderRegistry edge cases...");
+    
+    // Test registry with maxPlaceholders = 1
+    PlaceholderRegistry smallRegistry(1);
+    TEST_ASSERT_TRUE_MESSAGE(smallRegistry.registerProgmemData("%A%", test_css_data), 
+        "Should register placeholder in small registry");
+    TEST_ASSERT_FALSE_MESSAGE(smallRegistry.registerProgmemData("%B%", test_js_data), 
+        "Should reject second placeholder in small registry");
+    
+    // Test placeholder name at maximum length
+    char maxName[25];
+    strncpy(maxName, "%", sizeof(maxName) - 1);
+    maxName[0] = '%';
+    for (int i = 1; i < 22; i++) {
+        maxName[i] = 'A';
+    }
+    maxName[22] = '%';
+    maxName[23] = '\0';
+    
+    PlaceholderRegistry registry(10);
+    TEST_ASSERT_TRUE_MESSAGE(registry.registerProgmemData(maxName, test_css_data), 
+        "Should register placeholder with max length name");
+    
+    // Test placeholder name over maximum length
+    char overName[30];
+    overName[0] = '%';
+    for (int i = 1; i < 27; i++) {
+        overName[i] = 'A';
+    }
+    overName[27] = '%';
+    overName[28] = '\0';
+    
+    TEST_ASSERT_FALSE_MESSAGE(registry.registerProgmemData(overName, test_css_data), 
+        "Should reject placeholder with over max length name");
+    
+    // Test length calculation
+    size_t progmemLen = PlaceholderRegistry::getProgmemLength(test_css_data);
+    TEST_ASSERT_GREATER_THAN_MESSAGE(0, progmemLen, "Should calculate PROGMEM length");
+    
+    // Test length calculation with null
+    size_t nullLen = PlaceholderRegistry::getProgmemLength(nullptr);
+    TEST_ASSERT_EQUAL_MESSAGE(0, nullLen, "Should return 0 for null PROGMEM data");
+    
+    // Test RAM length calculation
+    size_t ramLen = PlaceholderRegistry::getRamLength((const void*)getTestRamData);
+    TEST_ASSERT_GREATER_THAN_MESSAGE(0, ramLen, "Should calculate RAM length");
+    
+    // Test RAM length calculation with null
+    size_t nullRamLen = PlaceholderRegistry::getRamLength(nullptr);
+    TEST_ASSERT_EQUAL_MESSAGE(0, nullRamLen, "Should return 0 for null RAM getter");
+    
+    Serial.println("[TEST]   PlaceholderRegistry edge case tests completed successfully");
+}
+

test/test_template_engine/tests/test_template_context.cpp

@@ -0,0 +1,324 @@
+#include <unity.h>
+#include <Arduino.h>
+#include <TemplateEngine.h>
+#include "../templates/simple_templates.h"
+#include "../utils/test_utils.h"
+
+// Test TemplateContext initialization
+void test_template_context_initialization() {
+    Serial.println("[TEST]   Testing TemplateContext initialization...");
+    
+    TemplateContext ctx;
+    
+    // Test default constructor
+    TEST_ASSERT_EQUAL_MESSAGE(TemplateRenderState::TEXT, ctx.state, 
+        "Initial state should be TEXT");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.renderingDepth, "Initial renderingDepth should be 0");
+    TEST_ASSERT_NULL_MESSAGE(ctx.getCurrentContext(), "Initial context should be null");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.placeholderPos, "Initial placeholderPos should be 0");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.bufferPos, "Initial bufferPos should be 0");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.bufferLen, "Initial bufferLen should be 0");
+    TEST_ASSERT_NULL_MESSAGE(ctx.registry, "Initial registry should be null");
+    
+    // Test reset
+    ctx.pushContext(RenderingContextType::TEMPLATE, "TEST");
+    ctx.renderingDepth = 5;
+    ctx.reset();
+    
+    TEST_ASSERT_EQUAL_MESSAGE(TemplateRenderState::TEXT, ctx.state, 
+        "Reset state should be TEXT");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.renderingDepth, "Reset renderingDepth should be 0");
+    TEST_ASSERT_NULL_MESSAGE(ctx.getCurrentContext(), "Reset context should be null");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.placeholderPos, "Reset placeholderPos should be 0");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.bufferPos, "Reset bufferPos should be 0");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.bufferLen, "Reset bufferLen should be 0");
+    
+    // Test isComplete
+    TEST_ASSERT_FALSE_MESSAGE(ctx.isComplete(), "Should not be complete initially");
+    ctx.state = TemplateRenderState::COMPLETE;
+    TEST_ASSERT_TRUE_MESSAGE(ctx.isComplete(), "Should be complete when state is COMPLETE");
+    ctx.state = TemplateRenderState::ERROR;
+    TEST_ASSERT_TRUE_MESSAGE(ctx.isComplete(), "Should be complete when state is ERROR");
+    
+    // Test hasError
+    ctx.state = TemplateRenderState::TEXT;
+    TEST_ASSERT_FALSE_MESSAGE(ctx.hasError(), "Should not have error initially");
+    ctx.state = TemplateRenderState::ERROR;
+    TEST_ASSERT_TRUE_MESSAGE(ctx.hasError(), "Should have error when state is ERROR");
+    
+    // Test getStateString
+    ctx.state = TemplateRenderState::TEXT;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("TEXT", ctx.getStateString().c_str(), 
+        "Should return correct state string for TEXT");
+    ctx.state = TemplateRenderState::RENDERING_CONTEXT;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("RENDERING_CONTEXT", ctx.getStateString().c_str(), 
+        "Should return correct state string for RENDERING_CONTEXT");
+    ctx.state = TemplateRenderState::COMPLETE;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("COMPLETE", ctx.getStateString().c_str(), 
+        "Should return correct state string for COMPLETE");
+    ctx.state = TemplateRenderState::ERROR;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("ERROR", ctx.getStateString().c_str(), 
+        "Should return correct state string for ERROR");
+    
+    // Test setRegistry
+    PlaceholderRegistry registry(10);
+    ctx.setRegistry(&registry);
+    TEST_ASSERT_EQUAL_MESSAGE(&registry, ctx.registry, "Should set registry correctly");
+    
+    Serial.println("[TEST]   TemplateContext initialization tests completed successfully");
+}
+
+// Test TemplateContext stack
+void test_template_context_stack() {
+    Serial.println("[TEST]   Testing TemplateContext stack...");
+    
+    TemplateContext ctx;
+    const char* template1 = plain_text_template;
+    const char* template2 = single_placeholder_template;
+    const char* template3 = multiple_placeholders_template;
+    
+    size_t len1 = strlen_P(template1);
+    size_t len2 = strlen_P(template2);
+    size_t len3 = strlen_P(template3);
+    
+    // Test push context
+    ctx.pushContext(RenderingContextType::TEMPLATE, "%TEMPLATE1%");
+    RenderingContext* ctx1 = ctx.getCurrentContext();
+    ctx1->context.templateCtx.templateData = template1;
+    ctx1->context.templateCtx.templateLen = len1;
+    ctx1->context.templateCtx.isProgmem = true;
+    ctx1->context.templateCtx.position = 0;
+    
+    TEST_ASSERT_EQUAL_MESSAGE(1, ctx.renderingDepth, "Stack depth should be 1 after push");
+    TEST_ASSERT_NOT_NULL_MESSAGE(ctx.getCurrentContext(), "Current context should not be null");
+    TEST_ASSERT_EQUAL_MESSAGE(template1, ctx.getCurrentContext()->context.templateCtx.templateData, 
+        "Current template should be pushed template");
+    TEST_ASSERT_EQUAL_MESSAGE(len1, ctx.getCurrentContext()->context.templateCtx.templateLen, "Template length should be set");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.getCurrentContext()->context.templateCtx.position, "Template position should be reset");
+    
+    // Test push multiple templates
+    ctx.pushContext(RenderingContextType::TEMPLATE, "%TEMPLATE2%");
+    RenderingContext* ctx2 = ctx.getCurrentContext();
+    ctx2->context.templateCtx.templateData = template2;
+    ctx2->context.templateCtx.templateLen = len2;
+    ctx2->context.templateCtx.isProgmem = true;
+    ctx2->context.templateCtx.position = 0;
+    
+    TEST_ASSERT_EQUAL_MESSAGE(2, ctx.renderingDepth, "Stack depth should be 2 after second push");
+    TEST_ASSERT_EQUAL_MESSAGE(template2, ctx.getCurrentContext()->context.templateCtx.templateData, 
+        "Current template should be second pushed template");
+    
+    ctx.pushContext(RenderingContextType::TEMPLATE, "%TEMPLATE3%");
+    RenderingContext* ctx3 = ctx.getCurrentContext();
+    ctx3->context.templateCtx.templateData = template3;
+    ctx3->context.templateCtx.templateLen = len3;
+    ctx3->context.templateCtx.isProgmem = true;
+    ctx3->context.templateCtx.position = 0;
+    
+    TEST_ASSERT_EQUAL_MESSAGE(3, ctx.renderingDepth, "Stack depth should be 3 after third push");
+    
+    // Test pop context
+    ctx.popContext();
+    TEST_ASSERT_EQUAL_MESSAGE(2, ctx.renderingDepth, "Stack depth should be 2 after pop");
+    TEST_ASSERT_EQUAL_MESSAGE(template2, ctx.getCurrentContext()->context.templateCtx.templateData, 
+        "Current template should be previous template");
+    
+    ctx.popContext();
+    TEST_ASSERT_EQUAL_MESSAGE(1, ctx.renderingDepth, "Stack depth should be 1 after second pop");
+    TEST_ASSERT_EQUAL_MESSAGE(template1, ctx.getCurrentContext()->context.templateCtx.templateData, 
+        "Current template should be first template");
+    
+    ctx.popContext();
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.renderingDepth, "Stack depth should be 0 after third pop");
+    
+    // Test stack overflow
+    // Push up to MAX_RENDERING_DEPTH
+    for (int i = 0; i < TemplateContext::MAX_RENDERING_DEPTH; i++) {
+        ctx.pushContext(RenderingContextType::TEMPLATE, "%TEMPLATE%");
+        RenderingContext* c = ctx.getCurrentContext();
+        c->context.templateCtx.templateData = template1;
+        c->context.templateCtx.templateLen = len1;
+        c->context.templateCtx.isProgmem = true;
+        c->context.templateCtx.position = 0;
+    }
+    TEST_ASSERT_EQUAL_MESSAGE(TemplateContext::MAX_RENDERING_DEPTH, ctx.renderingDepth, 
+        "Stack depth should be at MAX_RENDERING_DEPTH");
+    
+    // Try to push one more (should error)
+    ctx.pushContext(RenderingContextType::TEMPLATE, "%OVERFLOW%");
+    TEST_ASSERT_EQUAL_MESSAGE(TemplateRenderState::ERROR, ctx.state, 
+        "State should be ERROR after stack overflow");
+    
+    // Test stack underflow
+    ctx.reset();
+    ctx.popContext();
+    TEST_ASSERT_EQUAL_MESSAGE(TemplateRenderState::ERROR, ctx.state, 
+        "State should be ERROR after stack underflow");
+    
+    // Test getStackTrace
+    ctx.reset();
+    ctx.pushContext(RenderingContextType::TEMPLATE, "%TEMPLATE1%");
+    ctx.getCurrentContext()->context.templateCtx.templateData = template1;
+    ctx.getCurrentContext()->context.templateCtx.templateLen = len1;
+    ctx.getCurrentContext()->context.templateCtx.isProgmem = true;
+    ctx.pushContext(RenderingContextType::TEMPLATE, "%TEMPLATE2%");
+    ctx.getCurrentContext()->context.templateCtx.templateData = template2;
+    ctx.getCurrentContext()->context.templateCtx.templateLen = len2;
+    ctx.getCurrentContext()->context.templateCtx.isProgmem = true;
+    String trace = ctx.getStackTrace();
+    TEST_ASSERT_TRUE_MESSAGE(trace.length() > 0, "Stack trace should not be empty");
+    TEST_ASSERT_TRUE_MESSAGE(trace.indexOf("TEMPLATE1") >= 0, 
+        "Stack trace should contain template1");
+    TEST_ASSERT_TRUE_MESSAGE(trace.indexOf("TEMPLATE2") >= 0, 
+        "Stack trace should contain template2");
+    
+    Serial.println("[TEST]   TemplateContext stack tests completed successfully");
+}
+
+// Test TemplateContext buffer management
+void test_template_context_buffer() {
+    Serial.println("[TEST]   Testing TemplateContext buffer management...");
+    
+    TemplateContext ctx;
+    const char* templateData = plain_text_template;
+    size_t templateLen = strlen_P(templateData);
+    
+    // Push a template context first
+    ctx.pushContext(RenderingContextType::TEMPLATE, "TEST");
+    RenderingContext* currentCtx = ctx.getCurrentContext();
+    currentCtx->context.templateCtx.templateData = templateData;
+    currentCtx->context.templateCtx.templateLen = templateLen;
+    currentCtx->context.templateCtx.isProgmem = true;
+    currentCtx->context.templateCtx.position = 0;
+    
+    // Test refillBuffer
+    bool refilled = ctx.refillBuffer();
+    TEST_ASSERT_TRUE_MESSAGE(refilled, "Should refill buffer successfully");
+    TEST_ASSERT_GREATER_THAN_MESSAGE(0, ctx.bufferLen, "Buffer length should be greater than 0");
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.bufferPos, "Buffer position should be 0 after refill");
+    
+    // Test getNextChar
+    char c1 = ctx.getNextChar();
+    TEST_ASSERT_EQUAL_MESSAGE('H', c1, "Should get first character");
+    TEST_ASSERT_EQUAL_MESSAGE(1, ctx.bufferPos, "Buffer position should be 1");
+    
+    // Test getNextChar multiple times
+    char c2 = ctx.getNextChar();
+    char c3 = ctx.getNextChar();
+    TEST_ASSERT_EQUAL_MESSAGE('e', c2, "Should get second character");
+    TEST_ASSERT_EQUAL_MESSAGE('l', c3, "Should get third character");
+    
+    // Test getAvailableBytes
+    size_t available = ctx.getAvailableBytes();
+    TEST_ASSERT_GREATER_THAN_MESSAGE(0, available, "Should have available bytes");
+    
+    // Test hasMoreData
+    TEST_ASSERT_TRUE_MESSAGE(ctx.hasMoreData(), "Should have more data initially");
+    
+    // Test getNextChar until end
+    ctx.reset();
+    ctx.pushContext(RenderingContextType::TEMPLATE, "TEST");
+    currentCtx = ctx.getCurrentContext();
+    currentCtx->context.templateCtx.templateData = templateData;
+    currentCtx->context.templateCtx.templateLen = templateLen;
+    currentCtx->context.templateCtx.isProgmem = true;
+    currentCtx->context.templateCtx.position = 0;
+    
+    int charCount = 0;
+    while (ctx.hasMoreData()) {
+        char c = ctx.getNextChar();
+        if (c == '\0') {
+            break;
+        }
+        charCount++;
+    }
+    TEST_ASSERT_GREATER_THAN_MESSAGE(0, charCount, "Should read all characters");
+    
+    // Test refillBuffer when at end
+    ctx.reset();
+    ctx.pushContext(RenderingContextType::TEMPLATE, "TEST");
+    currentCtx = ctx.getCurrentContext();
+    currentCtx->context.templateCtx.templateData = templateData;
+    currentCtx->context.templateCtx.templateLen = templateLen;
+    currentCtx->context.templateCtx.isProgmem = true;
+    currentCtx->context.templateCtx.position = templateLen;
+    
+    bool refilled2 = ctx.refillBuffer();
+    TEST_ASSERT_FALSE_MESSAGE(refilled2, "Should not refill when at end");
+    
+    // Test getNextChar when at end
+    ctx.reset();
+    ctx.pushContext(RenderingContextType::TEMPLATE, "TEST");
+    currentCtx = ctx.getCurrentContext();
+    currentCtx->context.templateCtx.templateData = templateData;
+    currentCtx->context.templateCtx.templateLen = templateLen;
+    currentCtx->context.templateCtx.position = templateLen;
+    
+    char c4 = ctx.getNextChar();
+    TEST_ASSERT_EQUAL_MESSAGE('\0', c4, "Should return null character at end");
+    
+    // Test resetPlaceholder
+    ctx.placeholderPos = 10;
+    strcpy(ctx.placeholderName, "%TEST%");
+    ctx.resetPlaceholder();
+    
+    TEST_ASSERT_EQUAL_MESSAGE(0, ctx.placeholderPos, "Placeholder position should be reset");
+    TEST_ASSERT_EQUAL_MESSAGE(0, strlen(ctx.placeholderName), 
+        "Placeholder name should be cleared");
+    
+    Serial.println("[TEST]   TemplateContext buffer tests completed successfully");
+}
+
+// Test TemplateContext state management
+void test_template_context_state() {
+    Serial.println("[TEST]   Testing TemplateContext state management...");
+    
+    TemplateContext ctx;
+    
+    // Test all state strings
+    ctx.state = TemplateRenderState::TEXT;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("TEXT", ctx.getStateString().c_str(), 
+        "Should return TEXT for TEXT state");
+    
+    ctx.state = TemplateRenderState::BUILDING_PLACEHOLDER;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("BUILDING_PLACEHOLDER", ctx.getStateString().c_str(), 
+        "Should return BUILDING_PLACEHOLDER for BUILDING_PLACEHOLDER state");
+    
+    ctx.state = TemplateRenderState::RENDERING_CONTEXT;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("RENDERING_CONTEXT", ctx.getStateString().c_str(), 
+        "Should return RENDERING_CONTEXT for RENDERING_CONTEXT state");
+    
+    ctx.state = TemplateRenderState::COMPLETE;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("COMPLETE", ctx.getStateString().c_str(), 
+        "Should return COMPLETE for COMPLETE state");
+    
+    ctx.state = TemplateRenderState::ERROR;
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("ERROR", ctx.getStateString().c_str(), 
+        "Should return ERROR for ERROR state");
+    
+    // Test isComplete for all states
+    ctx.state = TemplateRenderState::TEXT;
+    TEST_ASSERT_FALSE_MESSAGE(ctx.isComplete(), "TEXT should not be complete");
+    
+    ctx.state = TemplateRenderState::BUILDING_PLACEHOLDER;
+    TEST_ASSERT_FALSE_MESSAGE(ctx.isComplete(), "BUILDING_PLACEHOLDER should not be complete");
+    
+    ctx.state = TemplateRenderState::RENDERING_CONTEXT;
+    TEST_ASSERT_FALSE_MESSAGE(ctx.isComplete(), "RENDERING_CONTEXT should not be complete");
+    
+    ctx.state = TemplateRenderState::COMPLETE;
+    TEST_ASSERT_TRUE_MESSAGE(ctx.isComplete(), "COMPLETE should be complete");
+    
+    ctx.state = TemplateRenderState::ERROR;
+    TEST_ASSERT_TRUE_MESSAGE(ctx.isComplete(), "ERROR should be complete");
+    
+    // Test hasError for all states
+    ctx.state = TemplateRenderState::TEXT;
+    TEST_ASSERT_FALSE_MESSAGE(ctx.hasError(), "TEXT should not have error");
+    
+    ctx.state = TemplateRenderState::ERROR;
+    TEST_ASSERT_TRUE_MESSAGE(ctx.hasError(), "ERROR should have error");
+    
+    Serial.println("[TEST]   TemplateContext state tests completed successfully");
+}
+

test/test_template_engine/utils/test_utils.cpp

@@ -0,0 +1,62 @@
+#include "test_utils.h"
+#include <unity.h>
+#include <pgmspace.h>
+
+// Helper function to capture rendered output
+String captureRenderedOutput(TemplateContext& ctx, size_t bufferSize) {
+    String output;
+    uint8_t* buffer = new uint8_t[bufferSize];
+    
+    if (!buffer) {
+        return output;
+    }
+    
+    while (!TemplateRenderer::isComplete(ctx)) {
+        size_t written = TemplateRenderer::renderNextChunk(ctx, buffer, bufferSize);
+        if (written > 0) {
+            // Arduino String doesn't have (const char*, size_t) constructor
+            // Use substring approach or create temporary string
+            char* temp = new char[written + 1];
+            memcpy(temp, buffer, written);
+            temp[written] = '\0';
+            output += String(temp);
+            delete[] temp;
+        } else {
+            break;
+        }
+    }
+    
+    delete[] buffer;
+    return output;
+}
+
+// Helper function to compare rendered output
+bool compareRenderedOutput(const String& expected, TemplateContext& ctx, size_t bufferSize) {
+    String actual = captureRenderedOutput(ctx, bufferSize);
+    return actual == expected;
+}
+
+// Note: For test RAM getters, define them as regular functions in test files
+// Example:
+//   static String testData = "test";
+//   const char* getTestData() { return testData.c_str(); }
+
+// Helper function to verify template output
+void verifyTemplateOutput(const char* templateData, PlaceholderRegistry& registry, const String& expected) {
+    TemplateContext ctx;
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, templateData);
+    
+    String actual = captureRenderedOutput(ctx);
+    TEST_ASSERT_EQUAL_STRING_MESSAGE(expected.c_str(), actual.c_str(), 
+        "Template output should match expected");
+}
+
+// Helper function to render template to string
+String renderTemplateToString(const char* templateData, PlaceholderRegistry& registry, size_t bufferSize) {
+    TemplateContext ctx;
+    ctx.setRegistry(&registry);
+    TemplateRenderer::initializeContext(ctx, templateData);
+    return captureRenderedOutput(ctx, bufferSize);
+}
+

test/test_template_engine/utils/test_utils.h

@@ -0,0 +1,34 @@
+#ifndef TEST_UTILS_H
+#define TEST_UTILS_H
+
+#include <Arduino.h>
+#include <TemplateEngine.h>
+
+// Test structure and state management
+using TestFn = void(*)();
+
+struct TestCase {
+    const char* name;
+    TestFn fn;
+    uint16_t line;
+};
+
+#define TEST_ENTRY(fn) { #fn, fn, __LINE__ }
+
+// Helper function to capture rendered output
+String captureRenderedOutput(TemplateContext& ctx, size_t bufferSize = 512);
+
+// Helper function to compare rendered output
+bool compareRenderedOutput(const String& expected, TemplateContext& ctx, size_t bufferSize = 512);
+
+// Helper function to create test RAM getter
+// Note: This is a simple wrapper - for actual tests, define getter functions directly
+
+// Helper function to verify template output
+void verifyTemplateOutput(const char* templateData, PlaceholderRegistry& registry, const String& expected);
+
+// Helper function to render template to string
+String renderTemplateToString(const char* templateData, PlaceholderRegistry& registry, size_t bufferSize = 512);
+
+#endif // TEST_UTILS_H
+