diff --git a/docs/brainstorming/template-compile.md b/docs/brainstorming/template-compile.md
new file mode 100644
index 0000000000000..908c95a82138f
--- /dev/null
+++ b/docs/brainstorming/template-compile.md
@@ -0,0 +1,21 @@
+# Template Compile Mode
+
+**Date:** 2026-02-04
+**Status:** Brainstorming
+
+---
+
+## Two Modes of Template Usage
+
+### 1. Flush Mode (current)
+- One-shot rendering, like `::sprintf`
+- Parse and render in a single pass
+
+### 2. Compile Mode (new idea)
+- A `compile()` method that:
+  - Captures placeholder offsets
+  - Returns a compiled/prepared template
+  - Accepts an array of replacements at render time
+  - Can be rendered multiple times efficiently from a single compilation
+
+**Use case:** When you need to render the same template structure repeatedly with different data, avoid re-parsing the template each time.
diff --git a/docs/brainstorming/template-html-context.md b/docs/brainstorming/template-html-context.md
new file mode 100644
index 0000000000000..c0691b0913335
--- /dev/null
+++ b/docs/brainstorming/template-html-context.md
@@ -0,0 +1,17 @@
+# Template HTML Context
+
+**Date:** 2026-02-04
+**Status:** Brainstorming
+
+---
+
+## HTML Context Constraints
+
+### Problem
+The HTML processor cannot normalize certain templates like `<td>` because `<td>` cannot exist outside of a `<table>` element. Context matters for valid HTML.
+
+### Potential Solutions
+- Use HTML processor instead of TAG processor
+- Add private methods for rendering nested templates
+- Processor creates a **fragment parser** at the template replacement location
+  - Fragment parser handles the child template with proper parent context
diff --git a/docs/plans/2026-02-04-template-api-redesign-v2.md b/docs/plans/2026-02-04-template-api-redesign-v2.md
new file mode 100644
index 0000000000000..75621fb65d1fe
--- /dev/null
+++ b/docs/plans/2026-02-04-template-api-redesign-v2.md
@@ -0,0 +1,125 @@
+# WP_HTML_Template API Redesign v2
+
+**Date:** 2026-02-04
+**Status:** Design Complete
+
+---
+
+## Overview
+
+A single-class template API with strict error handling. Parse once, bind values, render on demand.
+
+## Essential Interface
+
+```php
+class WP_HTML_Template {
+    public static function from(string $template): static;
+    public function bind(array $replacements): static;
+    public function render(): string|false;
+}
+```
+
+### Methods
+
+**`from(string $template): static`**
+
+Creates a template from a string.
+
+**`bind(array $replacements): static`**
+
+Returns a new immutable instance with replacements bound.
+
+**`render(): string|false`**
+
+Renders the template to an HTML string. Returns `false` on any error.
+
+## Usage Patterns
+
+### One-shot rendering
+
+```php
+$html = WP_HTML_Template::from('<p>Hello, </%name>!</p>')
+    ->bind(['name' => 'World'])
+    ->render();
+```
+
+### Nested templates (HTML injection)
+
+A template instance can be used as a replacement value. It will be rendered and injected as HTML (not escaped).
+
+```php
+$html = WP_HTML_Template::from('<div></%icon> </%message></div>')
+    ->bind([
+        'icon' => WP_HTML_Template::from('<span class="dashicon warning"></span>'),
+        'message' => 'Something went wrong.',
+    ])
+    ->render();
+```
+
+### Nested templates with their own placeholders
+
+```php
+$html = WP_HTML_Template::from('<div class="alert"></%content></div>')
+    ->bind([
+        'content' => WP_HTML_Template::from('<a href="</%url>"></%text></a>')
+            ->bind(['url' => '/help', 'text' => 'Learn more']),
+    ])
+    ->render();
+```
+
+### Loop rendering
+
+Parse once, bind and render with different values each iteration.
+
+```php
+$item_template = WP_HTML_Template::from('<li></%item></li>');
+
+foreach ($items as $item) {
+    echo $item_template->bind(['item' => $item])->render();
+}
+```
+
+## Replacement Values
+
+| Replacement Type | Text Context | Attribute Context |
+|------------------|--------------|-------------------|
+| String | Escaped | Escaped |
+| WP_HTML_Template | Rendered (HTML preserved) | `false` (error) |
+
+## Error Handling
+
+All error conditions cause `render()` to return `false`:
+
+| Condition | Result |
+|-----------|--------|
+| Missing replacement key | `false` |
+| Unused replacement key | `false` |
+| Template in attribute context | `false` |
+| HTML processing/normalization failure | `false` |
+
+Replacements must match placeholders exactly—no more, no less.
+
+## Immutability
+
+`bind()` always returns a new instance. Templates are safe to reuse:
+
+```php
+$tpl = WP_HTML_Template::from('<p></%text></p>');
+
+$a = $tpl->bind(['text' => 'Hello']);
+$b = $tpl->bind(['text' => 'World']);
+
+// $a and $b are independent
+echo $a->render(); // <p>Hello</p>
+echo $b->render(); // <p>World</p>
+```
+
+## Migration from Current API
+
+| Old | New |
+|-----|-----|
+| `T::sprintf($tpl, $r)` | `T::from($tpl)->bind($r)->render()` |
+| `T::from($tpl, $r)->render()` | `T::from($tpl)->bind($r)->render()` |
+| `T::from($tpl)->render($r)` | `T::from($tpl)->bind($r)->render()` |
+
+Breaking changes are acceptable since this is pre-release code (`@since 7.0.0`).
diff --git a/docs/plans/2026-02-04-template-api-redesign.md b/docs/plans/2026-02-04-template-api-redesign.md
new file mode 100644
index 0000000000000..874815b42399d
--- /dev/null
+++ b/docs/plans/2026-02-04-template-api-redesign.md
@@ -0,0 +1,153 @@
+# WP_HTML_Template API Redesign
+
+**Date:** 2026-02-04
+**Status:** Design Complete
+
+---
+
+## Overview
+
+Redesign the `WP_HTML_Template` API to support efficient repeated rendering. The key insight: parse once, bind many times, render on demand.
+
+## Classes
+
+### WP_HTML_Template
+
+The parsed template. Reusable across multiple bind operations.
+
+```php
+class WP_HTML_Template {
+    public static function render(string $template, array $replacements): string|false;
+    public static function from(string $template): self;
+    public function bind(array $replacements): WP_HTML_Bound_Template;
+}
+```
+
+### WP_HTML_Bound_Template
+
+A template with replacements bound. Ready to render.
+
+```php
+class WP_HTML_Bound_Template {
+    public function render(): string|false;
+}
+```
+
+## Usage Patterns
+
+### One-shot rendering
+
+For simple cases where you render once:
+
+```php
+echo WP_HTML_Template::render('<p></%name></p>', ['name' => 'Alice']);
+```
+
+### Reusable templates
+
+For loops or repeated use:
+
+```php
+$template = WP_HTML_Template::from('<li></%item></li>');
+
+foreach ($items as $item) {
+    echo $template->bind(['item' => $item])->render();
+}
+```
+
+### Nested templates
+
+Templates can contain other bound templates as replacements:
+
+```php
+$icon = WP_HTML_Template::from('<span class="icon </%class>"></span>');
+$message = WP_HTML_Template::from('<div class="alert"></%icon> </%text></div>');
+
+echo $message->bind([
+    'icon' => $icon->bind(['class' => 'warning']),
+    'text' => 'Something went wrong',
+])->render();
+```
+
+## Replacement Values
+
+Valid replacement types depend on context:
+
+| Context   | String | WP_HTML_Bound_Template |
+|-----------|--------|------------------------|
+| Text      | Yes    | Yes                    |
+| Attribute | Yes    | No (error)             |
+
+## Lazy Compilation
+
+`from()` stores the template string but does not parse it immediately. Compilation happens on the first `bind()` call and is cached for subsequent calls.
+
+```php
+// Just stores the string
+$template = WP_HTML_Template::from('<p></%name></p>');
+
+// First bind() triggers compilation, caches result
+$bound1 = $template->bind(['name' => 'Alice']);
+
+// Subsequent bind() reuses cached compilation
+$bound2 = $template->bind(['name' => 'Bob']);
+```
+
+## Compilation Output
+
+Compilation produces a list of placeholders with their positions and contexts:
+
+```php
+[
+    'template' => '<p class="</%class>"></%content></p>',
+    'placeholders' => [
+        'class'   => ['start' => 11, 'length' => 10, 'context' => 'attribute'],
+        'content' => ['start' => 23, 'length' => 12, 'context' => 'text'],
+    ],
+]
+```
+
+This allows `bind()` to validate replacements and `render()` to efficiently build the output string.
+
+## Error Handling
+
+Validation occurs at `bind()` time using the compiled placeholder information:
+
+### Missing key
+
+```php
+$t = WP_HTML_Template::from('<p></%name> </%age></p>');
+$t->bind(['name' => 'Alice']);
+// Warning: Missing replacement key 'age'
+```
+
+Rendering continues with missing placeholders removed.
+
+### Unused key
+
+```php
+$t->bind(['name' => 'Alice', 'age' => '30', 'extra' => 'ignored']);
+// Warning: Unused replacement key 'extra'
+```
+
+Rendering continues with unused keys ignored.
+
+### Wrong type for attribute
+
+```php
+$t = WP_HTML_Template::from('<p class="</%class>">text</p>');
+$t->bind(['class' => $otherTemplate->bind([...])]);
+// Warning: Replacement 'class' must be a string (attribute context)
+```
+
+`render()` returns `false`.
+
+## Migration from Current API
+
+| Old | New |
+|-----|-----|
+| `T::sprintf($tpl, $r)` | `T::render($tpl, $r)` |
+| `T::from($tpl, $r)->render()` | `T::from($tpl)->bind($r)->render()` |
+| `T::from($tpl)->render($r)` | `T::from($tpl)->bind($r)->render()` |
+
+Breaking changes are acceptable since this is pre-release code (`@since 7.0.0`).
diff --git a/docs/plans/2026-02-06-unified-edits-array-design.md b/docs/plans/2026-02-06-unified-edits-array-design.md
new file mode 100644
index 0000000000000..c5752fd227061
--- /dev/null
+++ b/docs/plans/2026-02-06-unified-edits-array-design.md
@@ -0,0 +1,106 @@
+# Unified Edits Array Design
+
+## Problem
+
+`WP_HTML_Template` currently uses three separate arrays to track compiled data:
+
+- `$compiled` — placeholder offsets, keyed by name, with context
+- `$text_normalizations` — `[start, length, normalized_text]` tuples
+- `$attr_escapes` — `[start, length]` tuples (computed at render time)
+
+These serve similar purposes (tracking spans to replace) but have different shapes and processing logic. The render method builds an intermediate `$updates` array from all three, sorts it, then applies replacements.
+
+Additionally, `attr_escapes` defers computation to render time unnecessarily — the template string is immutable, so decode→re-encode can happen at compile time.
+
+## Design
+
+Replace all three arrays with two:
+
+### `$edits` — unified edit list
+
+A flat array of edit operations, naturally ordered by ascending offset (the processor walks the document linearly). Each entry is one of:
+
+**Pre-computed replacement** (normalizations and escapes):
+```php
+['start' => 100, 'length' => 5, 'replacement' => '&amp;']
+```
+
+**Placeholder reference** (needs render-time lookup):
+```php
+['start' => 200, 'length' => 12, 'placeholder' => 'username', 'context' => 'text']
+```
+
+The `context` field is `'text'` or `'attribute'`, used to validate that templates aren't inserted into attribute values.
+
+### `$placeholder_names` — validation index
+
+A set of placeholder names for O(1) lookup during `bind()`:
+
+```php
+['username' => true, 'title' => true]
+```
+
+This replaces the current pattern of iterating `$compiled` to build a lookup on every `bind()` call.
+
+## Compile-time changes
+
+1. **Pre-compute attribute escapes**: Move the decode→re-encode logic from `render()` to `compile()`. Store only if the result differs from the original span (same redundancy check as text normalizations).
+
+2. **Single array population**: As the processor encounters normalizations, escapes, or placeholders, append to `$edits` in document order.
+
+3. **Build placeholder index**: When encountering a placeholder, also add its name to `$placeholder_names`.
+
+## Render-time changes
+
+The render loop becomes a single reverse iteration:
+
+```php
+foreach (array_reverse($this->edits) as $edit) {
+    if (isset($edit['placeholder'])) {
+        // Look up replacement value
+        // Validate template-in-attribute
+        // Escape and apply
+    } else {
+        // Pre-computed, apply directly
+        $html = substr_replace($html, $edit['replacement'], $edit['start'], $edit['length']);
+    }
+}
+```
+
+No intermediate `$updates` array. No `usort()`.
+
+## Bind-time changes
+
+Validation uses `$placeholder_names` directly instead of building a lookup:
+
+```php
+// Check for missing keys
+foreach ($this->placeholder_names as $name => $_) {
+    // ... validate $name exists in $replacements
+}
+
+// Check for unused keys
+foreach ($replacements as $key => $_) {
+    // ... validate $key exists in $placeholder_names
+}
+```
+
+## Invariants
+
+- Offsets in `$edits` are strictly ascending (document order)
+- No overlapping spans
+- Entries have either `replacement` (pre-computed) or `placeholder` + `context` (render-time)
+- Every name in an edit with `placeholder` key exists in `$placeholder_names`
+
+## Trade-offs
+
+**Gains:**
+- Three properties → two properties
+- Render: three foreach loops + sort → one reverse iteration
+- Attribute escapes pre-computed (less render-time work)
+- Redundant escapes filtered out (fewer edits when template is well-formed)
+- Clearer mental model: "edits" are things to replace, "placeholder_names" is the validation index
+
+**Costs:**
+- Slightly more memory per placeholder entry (storing `context` per offset instead of once per name)
+- Loses grouping by placeholder name (negligible — hash lookups are cheap)
diff --git a/src/wp-includes/html-api/class-wp-html-tag-processor.php b/src/wp-includes/html-api/class-wp-html-tag-processor.php
index 69e3e5d2c7557..214e06502260a 100644
--- a/src/wp-includes/html-api/class-wp-html-tag-processor.php
+++ b/src/wp-includes/html-api/class-wp-html-tag-processor.php
@@ -708,7 +708,7 @@ class WP_HTML_Tag_Processor {
 	 * @since 6.2.0
 	 * @var WP_HTML_Attribute_Token[]
 	 */
-	private $attributes = array();
+	protected $attributes = array();
 
 	/**
 	 * Tracks spans of duplicate attributes on a given tag, used for removing
diff --git a/src/wp-includes/html-api/class-wp-html-template.php b/src/wp-includes/html-api/class-wp-html-template.php
new file mode 100644
index 0000000000000..033ea88e83a77
--- /dev/null
+++ b/src/wp-includes/html-api/class-wp-html-template.php
@@ -0,0 +1,470 @@
+<?php
+/**
+ * HTML API: WP_HTML_Template class
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ * @since 7.0.0
+ */
+
+class WP_HTML_Template {
+	/**
+	 * The template string.
+	 *
+	 * @since 7.0.0
+	 *
+	 * @var string
+	 */
+	private string $template_string;
+
+	private array $replacements = array();
+
+	/**
+	 * Whether the template has been compiled.
+	 *
+	 * @since 7.0.0
+	 * @var bool
+	 */
+	private bool $is_compiled = false;
+
+	/**
+	 * Unified edit operations list.
+	 *
+	 * Flat array in document order (ascending offsets). Each entry is one of:
+	 *
+	 * Pre-computed replacement (normalizations, escapes):
+	 *   ['start' => int, 'length' => int, 'replacement' => string]
+	 *
+	 * Placeholder reference (render-time lookup):
+	 *   ['start' => int, 'length' => int, 'placeholder' => string, 'context' => 'text'|'attribute']
+	 *
+	 * @since 7.0.0
+	 * @var array
+	 */
+	private array $edits = array();
+
+	/**
+	 * Placeholder names for O(1) validation.
+	 *
+	 * @since 7.0.0
+	 * @var array<string, true>
+	 */
+	private array $placeholder_names = array();
+
+	/**
+	 * Returns the compiled placeholder metadata.
+	 *
+	 * Derives the grouped structure from $edits on-demand.
+	 * If a placeholder appears in both text and attribute contexts,
+	 * the attribute context takes precedence (more restrictive).
+	 *
+	 * @since 7.0.0
+	 *
+	 * @return array Associative array of placeholder_name => metadata.
+	 */
+	public function get_placeholders(): array {
+		$this->compile();
+
+		$result = array();
+
+		foreach ( $this->edits as $edit ) {
+			if ( ! isset( $edit['placeholder'] ) ) {
+				continue;
+			}
+
+			$placeholder = $edit['placeholder'];
+			$context     = $edit['context'];
+
+			if ( ! isset( $result[ $placeholder ] ) ) {
+				$result[ $placeholder ] = array(
+					'offsets' => array(),
+					'context' => $context,
+				);
+			} else {
+				// Promote text context to attribute context.
+				if ( 'attribute' === $context ) {
+					$result[ $placeholder ]['context'] = 'attribute';
+				}
+			}
+
+			$result[ $placeholder ]['offsets'][] = array( $edit['start'], $edit['length'] );
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Compiles the template to extract placeholder metadata.
+	 *
+	 * Parses the template once and caches placeholder positions, lengths,
+	 * and contexts. If a placeholder appears in both text and attribute
+	 * contexts, the attribute context takes precedence (more restrictive).
+	 *
+	 * @since 7.0.0
+	 */
+	private function compile(): void {
+		if ( $this->is_compiled ) {
+			return;
+		}
+
+		$this->is_compiled       = true;
+		$this->edits             = array();
+		$this->placeholder_names = array();
+
+		$processor = ( new class( '', WP_HTML_Processor::CONSTRUCTOR_UNLOCK_CODE ) extends WP_HTML_Processor {
+			public function get_html(): string {
+				return $this->html;
+			}
+
+			public function get_bookmark( string $name ) {
+				return $this->bookmarks[ "_{$name}" ] ?? null;
+			}
+
+			public function get_tag_attributes(): array {
+				return $this->attributes;
+			}
+		} )::create_fragment( $this->template_string );
+
+		if ( null === $processor ) {
+			return;
+		}
+
+		while ( $processor->next_token() ) {
+			switch ( $processor->get_token_type() ) {
+				/*
+				 * Track text normalizations to prevent something like
+				 * `a<</%tag-name>u` from becoming `a<i>u` after replacement.
+				 */
+				case '#text':
+					$processor->set_bookmark( 'text' );
+					$mark = $processor->get_bookmark( 'text' );
+					if ( null === $mark ) {
+						break;
+					}
+					$normalized = $processor->serialize_token();
+					if ( 0 !== substr_compare( $processor->get_html(), $normalized, $mark->start, $mark->length ) ) {
+						$this->edits[] = array(
+							'start'       => $mark->start,
+							'length'      => $mark->length,
+							'replacement' => $normalized,
+						);
+					}
+					break;
+
+				case '#funky-comment':
+					$processor->set_bookmark( 'placeholder' );
+					$mark = $processor->get_bookmark( 'placeholder' );
+					if ( null === $mark ) {
+						break;
+					}
+
+					$start  = $mark->start;
+					$length = $mark->length;
+					$html   = $processor->get_html();
+
+					// Must be at least `</%x>` (5 chars) and start with `</%`
+					if ( $length < 5 || '%' !== $html[ $start + 2 ] ) {
+						break;
+					}
+
+					$placeholder = trim( substr( $html, $start + 3, $length - 4 ), " \t\n\r\f" );
+
+					// Valid placeholders match `/[a-z0-9_-]+/i`
+					if ( strlen( $placeholder ) !== strspn( $placeholder, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-' ) ) {
+						break;
+					}
+
+					// New: append placeholder edit and register name.
+					$this->edits[]                           = array(
+						'start'       => $start,
+						'length'      => $length,
+						'placeholder' => $placeholder,
+						'context'     => 'text',
+					);
+					$this->placeholder_names[ $placeholder ] = true;
+					break;
+
+				case '#tag':
+					if ( $processor->is_tag_closer() ) {
+						break;
+					}
+
+					$html = $processor->get_html();
+					foreach ( $processor->get_tag_attributes() as $attribute ) {
+						// Boolean attributes cannot contain placeholders.
+						if ( $attribute->is_true ) {
+							continue;
+						}
+						// At least `</%x>` to contain a placeholder.
+						if ( $attribute->value_length < 5 ) {
+							continue;
+						}
+
+						$last_offset = $attribute->value_starts_at;
+						$offset      = $attribute->value_starts_at;
+						$end         = $offset + $attribute->value_length;
+
+						while (
+							1 === preg_match(
+								'#</%[ \\t\\r\\f\\n]*([a-z0-9_-]+)[ \\t\\r\\f\\n]*>#i',
+								$html,
+								$matches,
+								PREG_OFFSET_CAPTURE,
+								$offset
+							)
+							&& $matches[0][1] < $end
+						) {
+							$placeholder  = $matches[1][0];
+							$match_start  = $matches[0][1];
+							$match_length = strlen( $matches[0][0] );
+
+							// Pre-compute escape for text segment before this placeholder.
+							if ( $match_start > $last_offset ) {
+								$seg_length = $match_start - $last_offset;
+								$original   = substr( $html, $last_offset, $seg_length );
+								$decoded    = WP_HTML_Decoder::decode_attribute( $original );
+								$escaped    = strtr(
+									$decoded,
+									array(
+										'&' => '&amp;',
+										'<' => '&lt;',
+										'>' => '&gt;',
+										"'" => '&apos;',
+										'"' => '&quot;',
+									)
+								);
+								// Only add edit if escaping actually changes the text.
+								if ( $escaped !== $original ) {
+									$this->edits[] = array(
+										'start'       => $last_offset,
+										'length'      => $seg_length,
+										'replacement' => $escaped,
+									);
+								}
+							}
+
+							// New: append placeholder edit and register name.
+							$this->edits[]                           = array(
+								'start'       => $match_start,
+								'length'      => $match_length,
+								'placeholder' => $placeholder,
+								'context'     => 'attribute',
+							);
+							$this->placeholder_names[ $placeholder ] = true;
+
+							$last_offset = $match_start + $match_length;
+							$offset      = $last_offset;
+						}
+
+						// Pre-compute escape for trailing text segment after last placeholder.
+						if ( $last_offset < $end ) {
+							$seg_length = $end - $last_offset;
+							$original   = substr( $html, $last_offset, $seg_length );
+							$decoded    = WP_HTML_Decoder::decode_attribute( $original );
+							$escaped    = strtr(
+								$decoded,
+								array(
+									'&' => '&amp;',
+									'<' => '&lt;',
+									'>' => '&gt;',
+									"'" => '&apos;',
+									'"' => '&quot;',
+								)
+							);
+							// Only add edit if escaping actually changes the text.
+							if ( $escaped !== $original ) {
+								$this->edits[] = array(
+									'start'       => $last_offset,
+									'length'      => $seg_length,
+									'replacement' => $escaped,
+								);
+							}
+						}
+					}
+					break;
+			}
+		}
+	}
+
+	private function __construct( string $template_string, array $replacements ) {
+		$this->template_string = $template_string;
+		$this->replacements    = $replacements;
+	}
+
+	/**
+	 * Creates a template from a string.
+	 *
+	 * @since 7.0.0
+	 *
+	 * @param string $template The template string with placeholders.
+	 * @return static The template instance.
+	 */
+	public static function from( string $template ): static {
+		return new static( $template, array() );
+	}
+
+	/**
+	 * Returns a new immutable instance with replacements bound.
+	 *
+	 * Triggers compilation if not already done. Validates replacements:
+	 * - Warns if a placeholder has no corresponding replacement
+	 * - Warns if a replacement key has no corresponding placeholder
+	 * - Warns if a template is used in attribute context
+	 *
+	 * @since 7.0.0
+	 *
+	 * @param array $replacements The replacement values.
+	 * @return static A new template instance with the replacements bound.
+	 */
+	public function bind( array $replacements ): static {
+		$this->compile();
+
+		// Check for missing keys (placeholder without replacement).
+		foreach ( $this->placeholder_names as $placeholder => $_ ) {
+			$placeholder = (string) $placeholder;
+			$found       = array_key_exists( $placeholder, $replacements );
+			if ( ! $found && ctype_digit( $placeholder ) ) {
+				$found = array_key_exists( (int) $placeholder, $replacements );
+			}
+			if ( ! $found ) {
+				_doing_it_wrong(
+					__METHOD__,
+					sprintf(
+						'Missing replacement for placeholder: %s',
+						$placeholder
+					),
+					'7.0.0'
+				);
+			}
+		}
+
+		// Check for unused keys (replacement without placeholder).
+		foreach ( $replacements as $key => $value ) {
+			$str_key = (string) $key;
+			$found   = isset( $this->placeholder_names[ $key ] ) || isset( $this->placeholder_names[ $str_key ] );
+			if ( ! $found ) {
+				_doing_it_wrong(
+					__METHOD__,
+					sprintf(
+						'Unused replacement key: %s',
+						$key
+					),
+					'7.0.0'
+				);
+			}
+		}
+
+		// Check for templates in attribute context.
+		foreach ( $this->edits as $edit ) {
+			if ( ! isset( $edit['placeholder'] ) || 'attribute' !== $edit['context'] ) {
+				continue;
+			}
+
+			$placeholder = $edit['placeholder'];
+			$key         = ctype_digit( $placeholder ) ? (int) $placeholder : $placeholder;
+			$value       = $replacements[ $key ] ?? $replacements[ $placeholder ] ?? null;
+
+			if ( $value instanceof self ) {
+				_doing_it_wrong(
+					__METHOD__,
+					sprintf(
+						'Template cannot be used in attribute context: %s',
+						$placeholder
+					),
+					'7.0.0'
+				);
+				break; // Only warn once per placeholder name.
+			}
+		}
+
+		$new                    = new static( $this->template_string, $replacements );
+		$new->is_compiled       = $this->is_compiled;
+		$new->edits             = $this->edits;
+		$new->placeholder_names = $this->placeholder_names;
+		return $new;
+	}
+
+	/**
+	 * Renders the template to an HTML string.
+	 *
+	 * Uses pre-compiled placeholder metadata to perform replacements
+	 * without re-parsing. Collects all updates (placeholder replacements,
+	 * text normalizations, attribute text escaping) and applies them
+	 * from end to start using substr_replace() to preserve positions.
+	 *
+	 * Returns false on any error:
+	 * - Missing replacement key (placeholder without corresponding replacement)
+	 * - Unused replacement key (replacement without corresponding placeholder)
+	 * - Template in attribute context
+	 * - HTML processing/normalization failure
+	 *
+	 * @since 7.0.0
+	 *
+	 * @return string|false The rendered HTML, or false on error.
+	 */
+	public function render(): string|false {
+		$this->compile();
+
+		if ( empty( $this->replacements ) ) {
+			return WP_HTML_Processor::normalize( $this->template_string ) ?? $this->template_string;
+		}
+
+		$escape_map = array(
+			'&' => '&amp;',
+			'<' => '&lt;',
+			'>' => '&gt;',
+			"'" => '&apos;',
+			'"' => '&quot;',
+		);
+
+		$html      = $this->template_string;
+		$used_keys = array();
+
+		// Process edits in reverse order (end to start) to preserve positions.
+		foreach ( array_reverse( $this->edits ) as $edit ) {
+			if ( isset( $edit['placeholder'] ) ) {
+				// Placeholder: look up replacement value.
+				$placeholder = $edit['placeholder'];
+
+				if ( array_key_exists( $placeholder, $this->replacements ) ) {
+					$key = $placeholder;
+				} elseif ( ctype_digit( $placeholder ) && array_key_exists( (int) $placeholder, $this->replacements ) ) {
+					$key = (int) $placeholder;
+				} else {
+					return false;
+				}
+
+				$used_keys[ $key ] = true;
+				$value             = $this->replacements[ $key ];
+
+				if ( $value instanceof self ) {
+					if ( 'attribute' === $edit['context'] ) {
+						return false;
+					}
+
+					$rendered = $value->render();
+					if ( false === $rendered ) {
+						return false;
+					}
+
+					$html = substr_replace( $html, $rendered, $edit['start'], $edit['length'] );
+				} elseif ( is_string( $value ) ) {
+					$escaped = strtr( $value, $escape_map );
+					$html    = substr_replace( $html, $escaped, $edit['start'], $edit['length'] );
+				} else {
+					return false;
+				}
+			} else {
+				// Pre-computed replacement: apply directly.
+				$html = substr_replace( $html, $edit['replacement'], $edit['start'], $edit['length'] );
+			}
+		}
+
+		// Return false if any replacement key was not used.
+		if ( count( $used_keys ) !== count( $this->replacements ) ) {
+			return false;
+		}
+
+		return WP_HTML_Processor::normalize( $html ) ?? $html;
+	}
+}
diff --git a/src/wp-settings.php b/src/wp-settings.php
index 60c220100f539..b80167116f541 100644
--- a/src/wp-settings.php
+++ b/src/wp-settings.php
@@ -276,6 +276,7 @@
 require ABSPATH . WPINC . '/html-api/class-wp-html-stack-event.php';
 require ABSPATH . WPINC . '/html-api/class-wp-html-processor-state.php';
 require ABSPATH . WPINC . '/html-api/class-wp-html-processor.php';
+require ABSPATH . WPINC . '/html-api/class-wp-html-template.php';
 require ABSPATH . WPINC . '/class-wp-block-processor.php';
 require ABSPATH . WPINC . '/class-wp-http.php';
 require ABSPATH . WPINC . '/class-wp-http-streams.php';
diff --git a/templating-examples.php b/templating-examples.php
new file mode 100644
index 0000000000000..2c9e4e80b83f3
--- /dev/null
+++ b/templating-examples.php
@@ -0,0 +1,205 @@
+<?php
+/**
+ * HTML Templating API - Usage Examples
+ *
+ * This file documents real patterns from WordPress core that could benefit
+ * from the WP_HTML_Template API. These are reference examples for API design.
+ *
+ * @see Trac #60229 - HTML API: Introduce HTML Templating
+ */
+
+die( 'demonstration - not for execution' );
+
+/**
+ * =============================================================================
+ * PATTERN 1: Translation functions with embedded HTML
+ * =============================================================================
+ *
+ * These patterns have HTML tags directly in the translatable string.
+ * Translators see the HTML, which is problematic.
+ */
+
+// src/wp-includes/functions.php:1620
+// Simple HTML tag in translation
+wp_die( __( '<strong>Error:</strong> This is not a valid feed template.' ), '', array( 'response' => 404 ) );
+
+// src/wp-includes/functions.php:1844-1845
+// Link with placeholder inside translation
+$wpdb->error = sprintf(
+	/* translators: %s: Database repair URL. */
+	__( 'One or more database tables are unavailable. The database may need to be <a href="%s">repaired</a>.' ),
+	'maint/repair.php?referrer=is_blog_installed'
+);
+
+// src/wp-admin/edit-form-advanced.php:185
+// HTML wrapper injected as sprintf parameter
+$messages['post'][9] = sprintf( __( 'Post scheduled for: %s.' ), '<strong>' . $scheduled_date . '</strong>' ) . $scheduled_post_link_html;
+
+// src/wp-admin/revision.php:145-147
+// Multiple strong tags for emphasis in help text
+$revisions_overview .= '<ul><li>' . __( 'To navigate between revisions, <strong>drag the slider handle left or right</strong> or <strong>use the Previous or Next buttons</strong>.' ) . '</li>';
+$revisions_overview .= '<li>' . __( 'Compare two different revisions by <strong>selecting the &#8220;Compare any two revisions&#8221; box</strong> to the side.' ) . '</li>';
+$revisions_overview .= '<li>' . __( 'To restore a revision, <strong>click Restore This Revision</strong>.' ) . '</li></ul>';
+
+// src/wp-includes/theme.php:978-979
+// Context translation (_x) with HTML error prefix
+return new WP_Error(
+	'theme_wp_php_incompatible',
+	sprintf(
+		/* translators: %s: Theme name. */
+		_x( '<strong>Error:</strong> Current WordPress and PHP versions do not meet minimum requirements for %s.', 'theme' ),
+		$theme->display( 'Name' )
+	)
+);
+
+// src/wp-includes/widgets/class-wp-widget-text.php:542
+// Complex: _e() with embedded link and HTML entities
+_e( 'Did you know there is a &#8220;Custom HTML&#8221; widget now? You can find it by pressing the &#8220;<a class="add-widget" href="#">Add a Widget</a>&#8221; button and searching for &#8220;HTML&#8221;. Check it out to add some custom code to your site!' );
+
+// src/wp-includes/blocks/comments-title.php:29
+// HTML entities (curly quotes) in translation
+$post_title = sprintf( __( '&#8220;%s&#8221;' ), get_the_title() );
+
+// src/wp-includes/blocks/latest-posts.php:164-166
+// Complex nested HTML with multiple escaped placeholders
+$trimmed_excerpt .= sprintf(
+	/* translators: 1: A URL to a post, 2: Hidden accessibility text: Post title */
+	__( '… <a class="wp-block-latest-posts__read-more" href="%1$s" rel="noopener noreferrer">Read more<span class="screen-reader-text">: %2$s</span></a>' ),
+	esc_url( $post_link ),
+	esc_html( $title )
+);
+
+// src/wp-admin/includes/class-plugin-upgrader.php:60
+// HTML span wrapping another placeholder (double sprintf)
+$this->strings['downloading_package'] = sprintf( __( 'Downloading update from %s&#8230;' ), '<span class="code pre">%s</span>' );
+
+// src/wp-admin/includes/privacy-tools.php:404
+// Code tag wrapping technical reference
+sprintf( __( 'The %s post meta must be an array.' ), '<code>_export_data_grouped</code>' );
+
+// src/wp-admin/widgets.php:24
+// Full paragraph with embedded documentation link
+wp_die( __( 'The theme you are currently using is not widget-aware, meaning that it has no sidebars that you are able to change. For information on making your theme widget-aware, please <a href="https://developer.wordpress.org/themes/functionality/widgets/">follow these instructions</a>.' ) );
+
+// src/wp-admin/revision.php:158
+// Link in translation without placeholders
+$revisions_sidebar .= '<p>' . __( '<a href="https://wordpress.org/documentation/article/revisions/">Revisions Management</a>' ) . '</p>';
+
+
+/**
+ * =============================================================================
+ * PATTERN 2: sprintf with manual escaping (non-translation)
+ * =============================================================================
+ *
+ * These patterns require developers to choose the correct escape function
+ * for each context (esc_url, esc_attr, esc_html).
+ */
+
+// src/wp-includes/blocks/post-title.php:41
+// Link with multiple escaped attributes
+$rel   = ! empty( $attributes['rel'] ) ? 'rel="' . esc_attr( $attributes['rel'] ) . '"' : '';
+$title = sprintf(
+	'<a href="%1$s" target="%2$s" %3$s>%4$s</a>',
+	esc_url( get_the_permalink( $block->context['postId'] ) ),
+	esc_attr( $attributes['linkTarget'] ),
+	$rel,    // Note: $rel already has esc_attr inside
+	$title   // Note: $title escaping unclear
+);
+
+// src/wp-includes/blocks/avatar.php:68
+// Similar link pattern for avatar
+$avatar_block = sprintf(
+	'<a href="%1$s" target="%2$s" %3$s class="wp-block-avatar__link">%4$s</a>',
+	esc_url( get_author_posts_url( $author_id ) ),
+	esc_attr( $attributes['linkTarget'] ),
+	$label,        // aria-label attribute, already escaped
+	$avatar_block  // Inner HTML
+);
+
+// src/wp-includes/formatting.php:3476
+// Image tag with esc_url and esc_attr
+return sprintf(
+	'<img src="%s" alt="%s" class="wp-smiley" style="height: 1em; max-height: 1em;" />',
+	esc_url( $src_url ),
+	esc_attr( $smiley )
+);
+
+// src/wp-includes/class-wp-styles.php:204-211
+// Link tag with nested sprintf for conditional attribute
+$tag = sprintf(
+	"<link rel='%s' id='%s-css'%s href='%s' media='%s' />\n",
+	$rel,                                                    // Not escaped
+	esc_attr( $handle ),
+	$title ? sprintf( " title='%s'", esc_attr( $title ) ) : '',
+	$href,                                                   // Not escaped
+	esc_attr( $media )
+);
+
+
+/**
+ * =============================================================================
+ * PATTERN 3: Building aria-label attributes
+ * =============================================================================
+ */
+
+// src/wp-includes/blocks/avatar.php:65
+// Aria label with translation and escaping
+$label = 'aria-label="' . esc_attr( sprintf( __( '(%s author archive, opens in a new tab)' ), $author_name ) ) . '"';
+
+
+/**
+ * =============================================================================
+ * POTENTIAL TEMPLATING ALTERNATIVES
+ * =============================================================================
+ *
+ * How these patterns could look with WP_HTML_Template.
+ */
+
+/*
+ * OPTION A: Template wraps translation (structure in code, text translated)
+ *
+ * HTML structure stays in PHP code, only text content is translated.
+ */
+
+// Instead of: __( '<strong>Error:</strong> This is not a valid feed template.' )
+WP_HTML_Template::render(
+	'<strong></%label></strong> </%message>',
+	array(
+		'label'   => __( 'Error:' ),
+		'message' => __( 'This is not a valid feed template.' ),
+	)
+);
+
+// Instead of: sprintf( __( 'Post scheduled for: %s.' ), '<strong>' . $date . '</strong>' )
+WP_HTML_Template::render(
+	__( 'Post scheduled for: %s.', 'template-placeholder' ), // Special handling?
+	// Or:
+	'</%before><strong></%date></strong></%after>',
+	array(
+		'before' => __( 'Post scheduled for: ' ),
+		'date'   => $scheduled_date,
+		'after'  => '',
+	)
+);
+
+/*
+ * OPTION B: Translation contains template placeholders
+ *
+ * Translated string includes the </%name> syntax directly.
+ * This is closer to how WordPress translations work today.
+ */
+
+// Instead of: sprintf( __( '... <a href="%s">repaired</a>.' ), $url )
+WP_HTML_Template::render(
+	__( 'One or more database tables are unavailable. The database may need to be <a href="</%url>">repaired</a>.' ),
+	array( 'url' => 'maint/repair.php?referrer=is_blog_installed' )
+);
+
+// Instead of: sprintf( __( '... href="%1$s" ... %2$s ...' ), esc_url($url), esc_html($title) )
+WP_HTML_Template::render(
+	__( '… <a class="wp-block-latest-posts__read-more" href="</%url>" rel="noopener noreferrer">Read more<span class="screen-reader-text">: </%title></span></a>' ),
+	array(
+		'url'   => $post_link,   // Auto-escaped as URL in href context
+		'title' => $title,       // Auto-escaped as text in text context
+	)
+);
diff --git a/tests/phpunit/tests/html-api/wpHtmlTemplate.php b/tests/phpunit/tests/html-api/wpHtmlTemplate.php
new file mode 100644
index 0000000000000..dd730a5ba3ab1
--- /dev/null
+++ b/tests/phpunit/tests/html-api/wpHtmlTemplate.php
@@ -0,0 +1,946 @@
+<?php
+/**
+ * Unit tests covering WP_HTML_Template functionality.
+ *
+ * @package WordPress
+ * @subpackage HTML-API
+ *
+ * @since 7.0.0
+ *
+ * @group html-api
+ * @group TBD
+ *
+ * @coversDefaultClass WP_HTML_Template
+ */
+
+use WP_HTML_Template as T;
+
+class Tests_HtmlApi_WpHtmlTemplate extends WP_UnitTestCase {
+	/**
+	 * Verifies that replacement text adjacent to angle brackets is escaped.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_escapes_text_adjacent_to_angle_brackets() {
+		$template_string = 'a<</%tag-name>>s';
+		$replacements    = array( 'tag-name' => 'i' );
+		$result          = T::from( $template_string )->bind( $replacements )->render();
+
+		$expected = 'a&lt;i&gt;s';
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	/**
+	 * Verifies that only the first of duplicate attributes is replaced.
+	 *
+	 * Note: Duplicate attributes are stripped per HTML spec, so placeholders
+	 * in duplicate attributes are ignored. Providing a replacement for such
+	 * placeholders would be an unused key error.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_replaces_only_in_first_duplicate_attribute() {
+		$template_string = '<meta a="</%replace></%replace-2>" a="</% no-replace >">';
+		$replacements    = array(
+			'replace'   => 'O',
+			'replace-2' => 'K',
+		);
+
+		$result = T::from( $template_string )->bind( $replacements )->render();
+
+		$expected = '<meta a="OK">';
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	/**
+	 * Verifies that attribute replacement is not recursive.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_attribute_replacement_is_not_recursive() {
+		$template_string = '<div a="</%replace>"></%replace></div>';
+		$replacements    = array(
+			'replace' => '</%replace>',
+		);
+
+		$result = T::from( $template_string )->bind( $replacements )->render();
+
+		$expected = '<div a="&lt;/%replace&gt;">&lt;/%replace&gt;</div>';
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	/**
+	 * Verifies that placeholder names allow surrounding whitespace.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_placeholder_names_allow_surrounding_whitespace() {
+		$template_string = "<meta name='</%\tn\n>' content='</% c\r\f>'>";
+		$replacements    = array(
+			'n' => 'the name',
+			'c' => 'the "content" & whatever else',
+		);
+
+		$result = T::from( $template_string )->bind( $replacements )->render();
+
+		$expected =
+			<<<'HTML'
+			<meta name="the name" content="the &quot;content&quot; &amp; whatever else">
+			HTML;
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	/**
+	 * Verifies that ampersands are escaped to prevent character reference injection.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_escapes_ampersand_to_prevent_character_reference_injection() {
+		$template_string = '<meta name="&</% placeholder >;">';
+		$replacements    = array( 'placeholder' => 'not' );
+		$result          = T::from( $template_string )->bind( $replacements )->render();
+
+		$expected =
+			<<<'HTML'
+			<meta name="&amp;not;">
+			HTML;
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	/**
+	 * Verifies that nested templates are rejected in attribute values.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 *
+	 * @expectedIncorrectUsage WP_HTML_Template::bind
+	 */
+	public function test_rejects_nested_template_in_attribute_value() {
+		$template_string = '<meta name="not-allowed" description="</%html>">';
+		$replacements    = array(
+			'html' => T::from( '<strong>This is not allowed!</strong>' ),
+		);
+		$this->assertFalse( T::from( $template_string )->bind( $replacements )->render() );
+	}
+
+	/**
+	 * @dataProvider data_template
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_template( string $template_string, array $replacements, string $expected ) {
+		$result = T::from( $template_string )->bind( $replacements )->render();
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	public static function data_template() {
+		return array(
+			'basic template (no placeholders)'   => array(
+				'<p>Hi!</p>',
+				array(),
+				'<p>Hi!</p>',
+			),
+
+			'basic text replacement'             => array(
+				'<p>Hello, </%name>!</p>',
+				array( 'name' => 'World' ),
+				'<p>Hello, World!</p>',
+			),
+
+			'escapes special characters in text' => array(
+				'<p>Hello, </%placeholder>!</p>',
+				array( 'placeholder' => 'Alice & Bob' ),
+				'<p>Hello, Alice &amp; Bob!</p>',
+			),
+
+			'escapes angle brackets in text'     => array(
+				'<p>Hello, </%name>!</p>',
+				array( 'name' => '<little-bobby-tags>' ),
+				'<p>Hello, &lt;little-bobby-tags&gt;!</p>',
+			),
+
+			'numeric placeholders'               => array(
+				'<p>Hello, </%0> and </%1>!</p>',
+				array( 'Alice', 'Bob' ),
+				'<p>Hello, Alice and Bob!</p>',
+			),
+
+			'repeated placeholders'              => array(
+				'<p></%0>, </% 0 >, </%name>, & </%name>!</p>',
+				array(
+					'Alice',
+					'name' => 'Bob',
+				),
+				'<p>Alice, Alice, Bob, &amp; Bob!</p>',
+			),
+
+			'nested template replacement'        => array(
+				'<p>Hello, </%html>',
+				array( 'html' => WP_HTML_Template::from( '<i>Alice</i> & <i>Bob</i>' ) ),
+				'<p>Hello, <i>Alice</i> &amp; <i>Bob</i></p>',
+			),
+
+			'replaces attribute values'          => array(
+				'<meta name="</%n>" content="</%c>">',
+				array(
+					'n' => 'the name',
+					'c' => 'the content',
+				),
+				'<meta name="the name" content="the content">',
+			),
+
+			'escapes attribute values'           => array(
+				'<meta content="</%c>">',
+				array(
+					'c' => 'the "content" & whatever else',
+				),
+				'<meta content="the &quot;content&quot; &amp; whatever else">',
+			),
+		);
+	}
+
+	/**
+	 * Test real-world patterns from WordPress core.
+	 *
+	 * @dataProvider data_real_world_examples
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_real_world_examples( string $template_string, array $replacements, string $expected ) {
+		$result = WP_HTML_Template::from( $template_string )->bind( $replacements )->render();
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	/**
+	 * Data provider with real-world patterns from WordPress core.
+	 *
+	 * Each test case is based on actual code patterns found in WordPress core
+	 * that could benefit from the WP_HTML_Template API.
+	 *
+	 * @return array[]
+	 */
+	public static function data_real_world_examples() {
+		/*
+		 * Group 1: Simple sprintf patterns with manual escaping.
+		 *
+		 * These patterns currently require developers to manually choose
+		 * the correct escape function (esc_url, esc_attr, esc_html).
+		 */
+
+		// src/wp-includes/formatting.php:3476 - Smiley image
+		yield 'formatting.php:3476 - smiley image tag' => array(
+			<<<'HTML'
+			<img src="</%src>" alt="</%alt>" class="wp-smiley" style="height: 1em; max-height: 1em;" />
+			HTML,
+			array(
+				'src' => 'https://example.com/smilies/:).png',
+				'alt' => ':)',
+			),
+			<<<'HTML'
+			<img src="https://example.com/smilies/:).png" alt=":)" class="wp-smiley" style="height: 1em; max-height: 1em;" />
+			HTML,
+		);
+
+		// src/wp-includes/blocks/post-title.php:41 - Post title link
+		yield 'blocks/post-title.php:41 - post title link' => array(
+			'<a href="</%url>" target="</%target>"></%title></a>',
+			array(
+				'url'    => 'https://example.com/hello-world/',
+				'target' => '_blank',
+				'title'  => 'Hello World',
+			),
+			'<a href="https://example.com/hello-world/" target="_blank">Hello World</a>',
+		);
+
+		// Same pattern with escaping needed
+		yield 'blocks/post-title.php:41 - post title link with special chars' => array(
+			"<a href='</%url>' target='</%target>'>\n</%title>\n</a>",
+			array(
+				'url'    => 'https://example.com/hello-world/?foo=1&bar=2',
+				'target' => '_blank',
+				'title'  => WP_HTML_Template::from( '\'<i></%italic></i>\' & <b>"</%bold>"</b>' )
+					->bind(
+						array(
+							'italic' => 'This',
+							'bold'   => 'That',
+						)
+					),
+			),
+			<<<'HTML'
+			<a href="https://example.com/hello-world/?foo=1&amp;bar=2" target="_blank">
+			&apos;<i>This</i>' &amp; <b>&quot;That"</b>
+			</a>
+			HTML,
+		);
+
+		/*
+		 * Group 2: Translation patterns with embedded HTML.
+		 *
+		 * These patterns have HTML directly in translatable strings.
+		 */
+
+		// src/wp-includes/functions.php:1620 - Error message (static, no placeholders)
+		yield 'functions.php:1620 - static error message' => array(
+			'<strong>Error:</strong> This is not a valid feed template.',
+			array(),
+			'<strong>Error:</strong> This is not a valid feed template.',
+		);
+
+		// src/wp-includes/functions.php:1844-1845 - Database repair link
+		yield 'functions.php:1844 - database repair link' => array(
+			<<<'HTML'
+			One or more database tables are unavailable. The database may need to be <a href="</%url>">repaired</a>.
+			HTML,
+			array(
+				'url' => 'maint/repair.php?referrer=is_blog_installed',
+			),
+			<<<'HTML'
+			One or more database tables are unavailable. The database may need to be <a href="maint/repair.php?referrer=is_blog_installed">repaired</a>.
+			HTML,
+		);
+
+		// src/wp-admin/edit-form-advanced.php:185 - Scheduled post date
+		yield 'edit-form-advanced.php:185 - scheduled post date' => array(
+			'Post scheduled for: <strong></%date></strong>.',
+			array(
+				'date' => 'March 15, 2025 at 10:30 am',
+			),
+			'Post scheduled for: <strong>March 15, 2025 at 10:30 am</strong>.',
+		);
+
+		// src/wp-includes/blocks/latest-posts.php:164-166 - Read more link with nested elements
+		yield 'blocks/latest-posts.php:164 - read more link with screen reader text' => array(
+			<<<'HTML'
+			… <a class="wp-block-latest-posts__read-more" href="</%url>" rel="noopener noreferrer">Read more<span class="screen-reader-text">: </%title></span></a>
+			HTML,
+			array(
+				'url'   => 'https://example.com/my-post/',
+				'title' => 'My Amazing Post',
+			),
+			<<<'HTML'
+			… <a class="wp-block-latest-posts__read-more" href="https://example.com/my-post/" rel="noopener noreferrer">Read more<span class="screen-reader-text">: My Amazing Post</span></a>
+			HTML,
+		);
+
+		// Same pattern with escaping needed
+		yield 'blocks/latest-posts.php:164 - read more with XSS attempt' => array(
+			<<<'HTML'
+			… <a class="wp-block-latest-posts__read-more" href="</%url>" rel="noopener noreferrer">Read more<span class="screen-reader-text">: </%title></span></a>
+			HTML,
+			array(
+				'url'   => 'javascript:alert("xss")',
+				'title' => '<script>alert("xss")</script>',
+			),
+			<<<'HTML'
+			… <a class="wp-block-latest-posts__read-more" href="javascript:alert(&quot;xss&quot;)" rel="noopener noreferrer">Read more<span class="screen-reader-text">: &lt;script&gt;alert("xss")&lt;/script&gt;</span></a>
+			HTML,
+		);
+
+		// src/wp-includes/theme.php:978-979 - Theme error with name
+		yield 'theme.php:978 - theme error message' => array(
+			<<<'HTML'
+			<strong>Error:</strong> Current WordPress and PHP versions do not meet minimum requirements for </%theme_name>.
+			HTML,
+			array(
+				'theme_name' => 'Twenty Twenty-Five',
+			),
+			<<<'HTML'
+			<strong>Error:</strong> Current WordPress and PHP versions do not meet minimum requirements for Twenty Twenty-Five.
+			HTML,
+		);
+
+		// src/wp-admin/includes/privacy-tools.php:404 - Code tag in error
+		yield 'privacy-tools.php:404 - code in error message' => array(
+			'The <code></%meta_key></code> post meta must be an array.',
+			array(
+				'meta_key' => '_export_data_grouped',
+			),
+			'The <code>_export_data_grouped</code> post meta must be an array.',
+		);
+
+		/*
+		 * Group 3: Edge cases.
+		 */
+
+		// Placeholder reuse (same placeholder multiple times)
+		yield 'placeholder reuse' => array(
+			'<label for="</%id>">Name:</label> <input id="</%id>" name="</%id>" type="text" />',
+			array(
+				'id' => 'user_name',
+			),
+			'<label for="user_name">Name:</label> <input id="user_name" name="user_name" type="text" />',
+		);
+
+		// Numeric placeholders like sprintf
+		yield 'numeric placeholders' => array(
+			'<a href="</%0>"></%1></a> by <a href="</%2>"></%3></a>',
+			array(
+				'https://example.com/post/',
+				'Post Title',
+				'https://example.com/author/',
+				'Author Name',
+			),
+			'<a href="https://example.com/post/">Post Title</a> by <a href="https://example.com/author/">Author Name</a>',
+		);
+
+		// Nested template (pre-escaped HTML)
+		yield 'nested template for complex structure' => array(
+			'<div class="error"></%icon> </%message></div>',
+			array(
+				'icon'    => WP_HTML_Template::from( '<span class="dashicons dashicons-warning"></span>' ),
+				'message' => 'Something went wrong.',
+			),
+			'<div class="error"><span class="dashicons dashicons-warning"></span> Something went wrong.</div>',
+		);
+
+		// Empty replacement
+		yield 'empty replacement value' => array(
+			'<p>Hello</%suffix></p>',
+			array(
+				'suffix' => '',
+			),
+			'<p>Hello</p>',
+		);
+
+		// HTML entities in template (should be preserved)
+		yield 'HTML entities in template' => array(
+			'<p>&#8220;</%quote>&#8221;</p>',
+			array(
+				'quote' => 'Hello World',
+			),
+			'<p>&#8220;Hello World&#8221;</p>',
+		);
+
+		// Multiple attributes on same element
+		yield 'multiple attributes on element' => array(
+			'<input type="</%type>" name="</%name>" value="</%value>" placeholder="</%placeholder>" />',
+			array(
+				'type'        => 'text',
+				'name'        => 'user_email',
+				'value'       => 'test@example.com',
+				'placeholder' => 'Enter your email',
+			),
+			'<input type="text" name="user_email" value="test@example.com" placeholder="Enter your email" />',
+		);
+
+		// Attribute value with quotes and special characters
+		yield 'attribute with quotes and ampersands' => array(
+			'<a href="</%url>" title="</%title>">Link</a>',
+			array(
+				'url'   => 'https://example.com/?a=1&b=2',
+				'title' => <<<'TEXT'
+				Click "here" for Tom & Jerry
+				TEXT,
+			),
+			<<<'HTML'
+			<a href="https://example.com/?a=1&amp;b=2" title="Click &quot;here&quot; for Tom &amp; Jerry">Link</a>
+			HTML,
+		);
+
+		// Self-closing void element
+		yield 'self-closing meta tag' => array(
+			'<meta name="</%name>" content="</%content>">',
+			array(
+				'name'    => 'description',
+				'content' => <<<'TEXT'
+				A page about "cats" & dogs
+				TEXT,
+			),
+			<<<'HTML'
+			<meta name="description" content="A page about &quot;cats&quot; &amp; dogs">
+			HTML,
+		);
+
+		// src/wp-includes/blocks/avatar.php:68 - Complex link with aria-label
+		yield 'blocks/avatar.php:68 - avatar link' => array(
+			<<<'HTML'
+			<a href="</%url>" target="</%target>" aria-label="</%aria_label>" class="wp-block-avatar__link"></%inner></a>
+			HTML,
+			array(
+				'url'        => 'https://example.com/author/johndoe/',
+				'target'     => '_blank',
+				'aria_label' => '(John Doe author archive, opens in a new tab)',
+				'inner'      => WP_HTML_Template::from( '<img src="https://example.com/avatar.jpg" alt="John Doe" />' ),
+			),
+			<<<'HTML'
+			<a href="https://example.com/author/johndoe/" target="_blank" aria-label="(John Doe author archive, opens in a new tab)" class="wp-block-avatar__link"><img src="https://example.com/avatar.jpg" alt="John Doe" /></a>
+			HTML,
+		);
+	}
+
+	/**
+	 * Verifies nested templates work correctly in a definition list.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_nested_templates_in_definition_list() {
+		$row_template = WP_HTML_Template::from( "<dt></%term></dt>\n<dd></%definition></dd>" );
+
+		$row_replacements = array();
+		for ( $i = 1; $i <= 3; $i++ ) {
+			$row_replacements[ "row-{$i}" ] = $row_template->bind(
+				array(
+					'term'       => "Term \"{$i}\"",
+					'definition' => WP_HTML_Template::from( '<abbr title="</%expansion>">IYKYK</abbr>: </%i>' )
+						->bind(
+							array(
+								'i'         => (string) $i,
+								'expansion' => '"If You Know You Know"',
+							)
+						),
+				)
+			);
+		}
+
+		$result = WP_HTML_Template::from(
+			<<<'HTML'
+			<dl>
+			</%row-1>
+			</%row-2>
+			</%row-3>
+			</dl>
+			HTML
+		)->bind( $row_replacements )->render();
+
+		$expected =
+			<<<'HTML'
+			<dl>
+			<dt>Term &quot;1&quot;</dt>
+			<dd><abbr title="&quot;If You Know You Know&quot;">IYKYK</abbr>: 1</dd>
+			<dt>Term &quot;2&quot;</dt>
+			<dd><abbr title="&quot;If You Know You Know&quot;">IYKYK</abbr>: 2</dd>
+			<dt>Term &quot;3&quot;</dt>
+			<dd><abbr title="&quot;If You Know You Know&quot;">IYKYK</abbr>: 3</dd>
+			</dl>
+			HTML;
+
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	/**
+	 * Verifies table templates are not yet supported.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_table_templates_not_yet_supported() {
+		$this->markTestSkipped( 'IN TABLE templates are not supported yet.' );
+		$header_tpl = WP_HTML_Template::from( '<tr><th></% ID ><th></% name ><th></% value ><th></% link >' )
+			->bind(
+				array(
+					'ID'    => 'ID',
+					'name'  => 'Name',
+					'value' => 'Value',
+					'link'  => 'Link',
+				)
+			);
+		$row_tpl    = WP_HTML_Template::from( '<tr><td></% ID ><td></% name ><td></% value ><td></% link >' );
+
+		$row_gen = ( function () {
+			static $i = 1;
+			yield array(
+				'ID'    => $i,
+				'name'  => 'Name {$i}',
+				'value' => WP_HTML_Template::from( 'Value <b>{$i}</b>' )->bind( array( 'i' => $i ) ),
+				'link'  => WP_HTML_Template::from( '<a href="</%url>"></%link-name></a>' )
+					->bind(
+						array(
+							'url'       => '/example/1',
+							'link-name' => 'Click here',
+						)
+					),
+			);
+		} )();
+
+		$result = WP_HTML_Template::from(
+			<<<'HTML'
+			<table>
+			<thead></%header>
+			<tbody>
+			</%row-1>
+			</%row-2>
+			</%row-3>
+			HTML
+		)->bind(
+			array(
+				'header' => $header_tpl,
+				'row-1'  => $row_tpl->bind( $row_gen->next() ),
+				'row-2'  => $row_tpl->bind( $row_gen->next() ),
+				'row-3'  => $row_tpl->bind( $row_gen->next() ),
+			)
+		)->render();
+
+		$expected =
+			<<<'HTML'
+			HTML;
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	/**
+	 * Verifies that attributes are replaced in atomic elements (SCRIPT, STYLE, TITLE).
+	 *
+	 * These elements have special parsing rules that skip their content,
+	 * but attributes should still be processed normally.
+	 *
+	 * @ticket 60229
+	 *
+	 * @dataProvider data_atomic_element_attributes
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_atomic_element_attributes_are_replaced( string $template_string, array $replacements, string $expected ) {
+		$result = T::from( $template_string )->bind( $replacements )->render();
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	public static function data_atomic_element_attributes() {
+		return array(
+			'SCRIPT element attributes'   => array(
+				'<script src="</%src>">console.log("hi")</script>',
+				array( 'src' => '/js/app.js' ),
+				'<script src="/js/app.js">console.log("hi")</script>',
+			),
+
+			'STYLE element attributes'    => array(
+				'<style media="</%media>">.foo { color: red; }</style>',
+				array( 'media' => 'screen' ),
+				'<style media="screen">.foo { color: red; }</style>',
+			),
+
+			'TITLE element attributes'    => array(
+				'<title lang="</%lang>">Page Title</title>',
+				array( 'lang' => 'en' ),
+				'<title lang="en">Page Title</title>',
+			),
+
+			'TEXTAREA element attributes' => array(
+				'<textarea name="</%name>">Some content</textarea>',
+				array( 'name' => 'my-textarea' ),
+				'<textarea name="my-textarea">Some content</textarea>',
+			),
+		);
+	}
+
+	/**
+	 * Verifies content placeholder behavior in elements with special parsing.
+	 *
+	 * - RAWTEXT elements (SCRIPT, STYLE): Content is skipped, placeholders preserved literally.
+	 * - RCDATA elements (TITLE, TEXTAREA): Content is processed but placeholders are not
+	 *   recognized - they're treated as literal text and HTML-escaped.
+	 *
+	 * With strict validation, providing a replacement for a placeholder that won't be
+	 * processed (inside SCRIPT/STYLE/TITLE/TEXTAREA) is an unused key error.
+	 *
+	 * @ticket 60229
+	 *
+	 * @dataProvider data_atomic_element_content_placeholders
+	 *
+	 * @todo Implement correct handling of atomic elements.
+	 *
+	 * @covers ::from
+	 * @covers ::render
+	 */
+	public function test_special_element_content_placeholder_behavior( string $template_string, string $expected ) {
+		$result = T::from( $template_string )->render();
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	public static function data_atomic_element_content_placeholders() {
+		return array(
+			// RAWTEXT elements (SCRIPT, STYLE): Content is truly skipped, placeholders preserved literally.
+			'SCRIPT content placeholder preserved'        => array(
+				'<script>var x = "</%name>";</script>',
+				'<script>var x = "</%name>";</script>',
+			),
+
+			'STYLE content placeholder preserved'         => array(
+				'<style>.foo { content: "</%content>"; }</style>',
+				'<style>.foo { content: "</%content>"; }</style>',
+			),
+
+			// RCDATA elements (TITLE, TEXTAREA): Content is processed but placeholder
+			// patterns are not recognized - they're treated as literal text and escaped.
+			'TITLE content placeholder escaped'           => array(
+				'<title>Hello </%name></title>',
+				'<title>Hello &lt;/%name&gt;</title>',
+			),
+
+			'TEXTAREA content placeholder escaped'        => array(
+				'<textarea></%placeholder></textarea>',
+				'<textarea>&lt;/%placeholder&gt;</textarea>',
+			),
+		);
+	}
+
+	/**
+	 * Verifies leading newline behavior in PRE elements.
+	 *
+	 * HTML5 specifies that a single leading newline immediately after the
+	 * <pre> start tag is ignored. This test documents the template behavior.
+	 *
+	 * @ticket 60229
+	 *
+	 * @dataProvider data_pre_element_leading_newline
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_pre_element_leading_newline_behavior( string $template_string, array $replacements, string $expected ) {
+		$this->markTestSkipped( 'PRE newline handling is not yet correct.' );
+
+		$result = T::from( $template_string )->bind( $replacements )->render();
+		$this->assertEqualHTML( $expected, $result );
+	}
+
+	public static function data_pre_element_leading_newline() {
+		return array(
+			'PRE without newline'        => array(
+				"<pre></%code></pre>",
+				array( 'code' => "line1\nline2"),
+				"<pre>line1\nline2</pre>",
+			),
+
+			'PRE with newline' => array(
+				"<pre>\n</%code></pre>",
+				array( 'code' =>  "line1\nline2"),
+				"<pre>line1\nline2</pre>",
+			),
+
+			'PRE with newline in replacement' => array(
+				"<pre>\n</%code></pre>",
+				array( 'code' =>   "line1\nline2"),
+				"<pre>line1\nline2</pre>",
+			),
+
+			'PRE with newline and newline in replacement' => array(
+				"<pre>\n</%code></pre>",
+				array( 'code' => "\nline1\nline2" ),
+				"<pre>\n\nline1\nline2</pre>",
+			),
+
+			'PRE with newline, newline replacement, and additional contents' => array(
+				"<pre>\n</%code><!--c--></pre>",
+				array( 'code' => "\nline1" ),
+				"<pre>\n\nline1<!--c--></pre>",
+			),
+		);
+	}
+
+	/**
+	 * Verifies bind() warns on missing replacement key.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::bind
+	 *
+	 * @expectedIncorrectUsage WP_HTML_Template::bind
+	 */
+	public function test_bind_warns_on_missing_key() {
+		$template = T::from( '<p></%name> </%age></p>' );
+		$template->bind( array( 'name' => 'Alice' ) );
+	}
+
+	/**
+	 * Verifies bind() warns on unused replacement key.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::bind
+	 *
+	 * @expectedIncorrectUsage WP_HTML_Template::bind
+	 */
+	public function test_bind_warns_on_unused_key() {
+		$template = T::from( '<p></%name></p>' );
+		$template->bind( array( 'name' => 'Alice', 'extra' => 'ignored' ) );
+	}
+
+	/**
+	 * Verifies bind() warns when template used in attribute context.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::bind
+	 *
+	 * @expectedIncorrectUsage WP_HTML_Template::bind
+	 */
+	public function test_bind_warns_on_template_in_attribute_context() {
+		$template = T::from( '<meta content="</%html>">' );
+		$template->bind( array( 'html' => T::from( '<b>nested</b>' ) ) );
+	}
+
+	/**
+	 * Verifies that get_placeholders returns placeholder metadata.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::get_placeholders
+	 */
+	public function test_get_placeholders_returns_metadata() {
+		$template = T::from( '<p class="</%class>"></%content></p>' );
+
+		$placeholders = $template->get_placeholders();
+
+		$this->assertArrayHasKey( 'class', $placeholders );
+		$this->assertArrayHasKey( 'content', $placeholders );
+		$this->assertSame( 'attribute', $placeholders['class']['context'] );
+		$this->assertSame( 'text', $placeholders['content']['context'] );
+	}
+
+	/**
+	 * Verifies text placeholders are extracted with correct offsets.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::get_placeholders
+	 */
+	public function test_extracts_text_placeholders_with_offsets() {
+		$template = T::from( '<p></%name></p>' );
+
+		$placeholders = $template->get_placeholders();
+
+		$this->assertArrayHasKey( 'name', $placeholders );
+		$this->assertSame( 'text', $placeholders['name']['context'] );
+		$this->assertCount( 1, $placeholders['name']['offsets'] );
+		// <p> is 3 chars, so </%name> starts at offset 3
+		$this->assertSame( 3, $placeholders['name']['offsets'][0][0] );
+		// </%name> is 8 chars
+		$this->assertSame( 8, $placeholders['name']['offsets'][0][1] );
+	}
+
+	/**
+	 * Verifies repeated text placeholders are captured.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::get_placeholders
+	 */
+	public function test_extracts_repeated_text_placeholders() {
+		$template = T::from( '<p></%name> and </%name></p>' );
+
+		$placeholders = $template->get_placeholders();
+
+		$this->assertArrayHasKey( 'name', $placeholders );
+		$this->assertCount( 2, $placeholders['name']['offsets'] );
+	}
+
+	/**
+	 * Verifies attribute placeholders are extracted.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::get_placeholders
+	 */
+	public function test_extracts_attribute_placeholders() {
+		$template = T::from( '<meta name="</%n>" content="</%c>">' );
+
+		$placeholders = $template->get_placeholders();
+
+		$this->assertArrayHasKey( 'n', $placeholders );
+		$this->assertArrayHasKey( 'c', $placeholders );
+		$this->assertSame( 'attribute', $placeholders['n']['context'] );
+		$this->assertSame( 'attribute', $placeholders['c']['context'] );
+	}
+
+	/**
+	 * Verifies context promotion from text to attribute.
+	 *
+	 * When a placeholder appears in both text and attribute contexts,
+	 * the attribute context takes precedence (more restrictive escaping).
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::get_placeholders
+	 */
+	/**
+	 * Verifies that static text around placeholders in attributes is escaped.
+	 *
+	 * @ticket 60229
+	 *
+	 * @covers ::from
+	 * @covers ::bind
+	 * @covers ::render
+	 */
+	public function test_escapes_static_text_around_placeholder_in_attribute() {
+		// Leading static text (prefix before placeholder)
+		$result = T::from( '<a href="/path/</%slug>">Link</a>' )
+			->bind( array( 'slug' => 'hello' ) )
+			->render();
+		$this->assertEqualHTML( '<a href="/path/hello">Link</a>', $result );
+
+		// Trailing static text (suffix after placeholder)
+		$result = T::from( '<a href="</%slug>/page">Link</a>' )
+			->bind( array( 'slug' => 'hello' ) )
+			->render();
+		$this->assertEqualHTML( '<a href="hello/page">Link</a>', $result );
+
+		// Ampersand in trailing static text must be escaped
+		$result = T::from( '<a href="</%base>&amp;extra=1">Link</a>' )
+			->bind( array( 'base' => '/search?q=test' ) )
+			->render();
+		$this->assertEqualHTML( '<a href="/search?q=test&amp;extra=1">Link</a>', $result );
+
+		// Ampersand entity in leading static text must not be double-escaped
+		$result = T::from( '<a href="/search?a=1&amp;b=</%val>">Link</a>' )
+			->bind( array( 'val' => '2' ) )
+			->render();
+		$this->assertEqualHTML( '<a href="/search?a=1&amp;b=2">Link</a>', $result );
+
+		// Character reference in trailing static text is preserved (not double-escaped)
+		$result = T::from( '<meta name="</%placeholder>&not;">' )
+			->bind( array( 'placeholder' => '' ) )
+			->render();
+		$this->assertEqualHTML( '<meta name="¬">', $result );
+	}
+
+	public function test_context_promotion_text_to_attribute() {
+		$template = T::from( '<a href="</%url>"></%url></a>' );
+
+		$placeholders = $template->get_placeholders();
+
+		$this->assertArrayHasKey( 'url', $placeholders );
+		// Both occurrences should use attribute context
+		$this->assertSame( 'attribute', $placeholders['url']['context'] );
+		$this->assertCount( 2, $placeholders['url']['offsets'] );
+	}
+}