diff --git a/README.md b/README.md
index da85802..c5be871 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,7 @@ See [For AI agents and LLMs](#for-ai-agents-and-llms).
 - [Usage documentation](https://professional.wiki/en/extension/native-markdown#Usage)
 - [Installation](#installation)
 - [Configuration](#configuration)
+- [Template transclusion](#template-transclusion)
 - [For AI agents and LLMs](#for-ai-agents-and-llms)
 - [Comparison with other Markdown extensions](#comparison-with-other-markdown-extensions)
 - [Development](#development)
@@ -92,6 +93,7 @@ wikitext and Markdown (in both directions) via `Special:ChangeContentModel`.
 | `$wgNativeMarkdownEverywhere` | `false` | New pages everywhere default to Markdown, the "Markdown wiki" mode (see exclusions below) |
 | `$wgNativeMarkdownSuffixDetection` | `false` | New pages whose title ends in `.md` default to Markdown, in every namespace |
 | `$wgNativeMarkdownAllowExternalImages` | `false` | Embed external `![alt](url)` images; when off they render as plain links |
+| `$wgNativeMarkdownTemplateTransclusion` | `false` | Expand `{{template}}` calls on Markdown pages; when off they stay literal text (see [Template transclusion](#template-transclusion)) |
 
 `$wgNativeMarkdownEverywhere` covers the whole prose wiki, but deliberately leaves some pages as wikitext: the
 discussion (Talk) namespaces, where signatures and threading depend on wikitext; the Template and MediaWiki
@@ -100,6 +102,46 @@ or JSON namespace). Titles ending in `.css`, `.js` or `.json` never default to M
 reserves those for code pages. External links honor the core `$wgNoFollowLinks` setting. Input size is bounded
 by core's `$wgMaxArticleSize`.
 
+## Template transclusion
+
+By default `{{...}}` is literal text on a Markdown page. Set
+`$wgNativeMarkdownTemplateTransclusion = true` to expand template calls instead, so Markdown pages can reuse a
+wiki's shared infoboxes, citations and navboxes:
+
+```markdown
+{{Infobox person
+| name = Ada Lovelace
+| born = 1815
+}}
+
+Ada Lovelace was an English **mathematician**, regarded as the first computer programmer.
+```
+
+Expansion delegates to MediaWiki's own parser, so template dependencies are tracked (editing a template
+reparses the pages that transclude it), recursion and size limits apply, and the output is sanitized exactly
+as wikitext is. Because it is the real parser, enabling this **also enables parser functions and magic words**
+inside the braces (`{{#if:}}`, `{{PAGENAME}}`, and so on).
+
+Placement follows the split between block and inline content:
+
+- A call on its **own line** produces block output, so an infobox table renders as a block rather than being
+  wrapped in a paragraph. It may span multiple lines, including blank parameter lines, until the braces balance.
+- A call **within a line** of text renders inline and must stay on a single line; multi-line calls have to
+  start on their own line.
+- Template arguments are wikitext, not Markdown. Inside a GFM table cell, escape argument pipes as `\|`. Write
+  `\{\{` to keep braces literal.
+- A block call with no closing `}}` is rendered as literal text through to the end of the page (Markdown
+  parsing cannot backtrack), so a forgotten brace shows up as visible braces to fix rather than a silent error.
+
+Out of scope in this version, by design:
+
+- `<ref>...</ref>` and `<references/>` in the Markdown body (these are tags, not `{{...}}`), and citation
+  state is not shared across separate calls on a page.
+- Transcluding another **Markdown** page with `{{:Page}}`: its source would be reinterpreted as wikitext, so
+  transclude wikitext pages instead. `subst:` does not substitute on save.
+- Enabling the setting does not reparse existing pages; they show template output once edited or purged. Run
+  `refreshLinks.php` to populate the template links eagerly.
+
 ## For AI agents and LLMs
 
 Markdown is the native read/write format of today's language models, and Native Markdown stores pages as
@@ -177,6 +219,7 @@ Initial release for MediaWiki 1.43+ with these features:
 * Clean full-text search: rendered prose is indexed, not raw markup; front matter excluded
 * YAML front matter parsed, hidden from output and stored as page metadata
 * Per-page model switching via `Special:ChangeContentModel`, namespace/suffix/wiki-wide activation modes
+* Opt-in template transclusion: `{{template}}` calls expand via the MediaWiki parser, with dependency tracking
 * XSS-safe by construction: raw HTML escaped, unsafe links blocked, external images off by default
 * `action=raw` / REST return the stored Markdown byte for byte, built for AI agents and git round-trips
 * CodeEditor syntax highlighting on Markdown pages
diff --git a/extension.json b/extension.json
index 7ad5e16..76b8996 100644
--- a/extension.json
+++ b/extension.json
@@ -56,6 +56,10 @@
 		"NativeMarkdownAllowExternalImages": {
 			"description": "If external images in markdown should be embedded. When false (default), they are rendered as plain links.",
 			"value": false
+		},
+		"NativeMarkdownTemplateTransclusion": {
+			"description": "If MediaWiki template calls ({{...}}) on markdown pages should be transcluded. When false (default), they are literal text. Enabling this also enables parser functions and magic words inside the braces, as expansion delegates to the MediaWiki parser.",
+			"value": false
 		}
 	},
 
diff --git a/src/Application/CommonMark/TemplateBraces.php b/src/Application/CommonMark/TemplateBraces.php
new file mode 100644
index 0000000..9672327
--- /dev/null
+++ b/src/Application/CommonMark/TemplateBraces.php
@@ -0,0 +1,57 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Application\CommonMark;
+
+/**
+ * Matching and measuring `{{...}}` brace spans, shared by the inline and block
+ * template-call parsers so they agree on what a balanced call is.
+ */
+final class TemplateBraces {
+
+	// Balanced `{{...}}` at the start of the string, allowing nested calls on a
+	// single line. The recursion refers to group 1 (not the whole pattern) so the
+	// `\A` anchor stays outside it; the atomic group bounds backtracking so
+	// adversarial brace runs fail fast to no match.
+	private const LEADING_CALL = '/\A(\{\{(?>[^{}\n]++|(?1))*\}\})/';
+
+	/**
+	 * The balanced `{{...}}` call the text begins with, or null when it does not
+	 * start with one (unbalanced, a `{{{` run, or a line break inside the braces).
+	 */
+	public static function matchLeadingCall( string $text ): ?string {
+		if ( preg_match( self::LEADING_CALL, $text, $matches ) === 1 ) {
+			return $matches[1];
+		}
+
+		return null;
+	}
+
+	/**
+	 * Net change in brace nesting across the text: `{{` opens a level, `}}` closes
+	 * one. Stray single braces are ignored, which is enough to find where an outer
+	 * call balances as its lines are accumulated.
+	 */
+	public static function depthDelta( string $text ): int {
+		$delta = 0;
+		$length = strlen( $text );
+
+		for ( $i = 0; $i < $length - 1; ) {
+			$pair = $text[$i] . $text[$i + 1];
+
+			if ( $pair === '{{' ) {
+				$delta++;
+				$i += 2;
+			} elseif ( $pair === '}}' ) {
+				$delta--;
+				$i += 2;
+			} else {
+				$i++;
+			}
+		}
+
+		return $delta;
+	}
+
+}
diff --git a/src/Application/CommonMark/TemplateCallBlock.php b/src/Application/CommonMark/TemplateCallBlock.php
new file mode 100644
index 0000000..96273f2
--- /dev/null
+++ b/src/Application/CommonMark/TemplateCallBlock.php
@@ -0,0 +1,21 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Application\CommonMark;
+
+use League\CommonMark\Node\Block\AbstractBlock;
+
+/**
+ * AST node for a block-level `{{...}}` call standing on its own line(s), such
+ * as an infobox. The continue parser fills in the raw wikitext and whether the
+ * braces balanced; an unbalanced call (never closed before end of input)
+ * degrades to escaped literal text instead of being expanded.
+ */
+final class TemplateCallBlock extends AbstractBlock {
+
+	public string $wikitext = '';
+	public bool $balanced = false;
+	public ?string $expandedHtml = null;
+
+}
diff --git a/src/Application/CommonMark/TemplateCallBlockParser.php b/src/Application/CommonMark/TemplateCallBlockParser.php
new file mode 100644
index 0000000..573c900
--- /dev/null
+++ b/src/Application/CommonMark/TemplateCallBlockParser.php
@@ -0,0 +1,57 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Application\CommonMark;
+
+use League\CommonMark\Parser\Block\AbstractBlockContinueParser;
+use League\CommonMark\Parser\Block\BlockContinue;
+use League\CommonMark\Parser\Block\BlockContinueParserInterface;
+use League\CommonMark\Parser\Cursor;
+
+/**
+ * Accumulates the lines of a block-level `{{...}}` call until the braces
+ * balance, then stores the raw wikitext on the TemplateCallBlock. A call that
+ * never closes before the end of input is marked unbalanced and later degrades
+ * to escaped literal text rather than being expanded.
+ */
+final class TemplateCallBlockParser extends AbstractBlockContinueParser {
+
+	private TemplateCallBlock $block;
+
+	/** @var string[] */
+	private array $lines = [];
+	private int $depth = 0;
+	private bool $finished = false;
+
+	public function __construct() {
+		$this->block = new TemplateCallBlock();
+	}
+
+	public function getBlock(): TemplateCallBlock {
+		return $this->block;
+	}
+
+	public function tryContinue( Cursor $cursor, BlockContinueParserInterface $activeBlockParser ): ?BlockContinue {
+		if ( $this->finished ) {
+			return BlockContinue::none();
+		}
+
+		return BlockContinue::at( $cursor );
+	}
+
+	public function addLine( string $line ): void {
+		$this->lines[] = $line;
+		$this->depth += TemplateBraces::depthDelta( $line );
+
+		if ( $this->depth <= 0 ) {
+			$this->finished = true;
+		}
+	}
+
+	public function closeBlock(): void {
+		$this->block->wikitext = trim( implode( "\n", $this->lines ) );
+		$this->block->balanced = $this->depth === 0;
+	}
+
+}
diff --git a/src/Application/CommonMark/TemplateCallBlockStartParser.php b/src/Application/CommonMark/TemplateCallBlockStartParser.php
new file mode 100644
index 0000000..80b9746
--- /dev/null
+++ b/src/Application/CommonMark/TemplateCallBlockStartParser.php
@@ -0,0 +1,50 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Application\CommonMark;
+
+use League\CommonMark\Parser\Block\BlockStart;
+use League\CommonMark\Parser\Block\BlockStartParserInterface;
+use League\CommonMark\Parser\Cursor;
+use League\CommonMark\Parser\MarkdownParserStateInterface;
+
+/**
+ * Starts a block-level template call when a line begins with `{{` (an infobox
+ * or navbox on its own line). A call that closes on the same line with trailing
+ * text is left for the inline parser; `{{{` argument syntax is left literal.
+ * The call may span multiple lines, including blank ones, until the braces
+ * balance; TemplateCallBlockParser accumulates those lines.
+ */
+final class TemplateCallBlockStartParser implements BlockStartParserInterface {
+
+	public function tryStart( Cursor $cursor, MarkdownParserStateInterface $parserState ): ?BlockStart {
+		if ( $cursor->isIndented() || $cursor->getNextNonSpaceCharacter() !== '{' ) {
+			return BlockStart::none();
+		}
+
+		$line = $cursor->getRemainder();
+
+		if ( preg_match( '/^[ \t]*\{\{(?!\{)/', $line ) !== 1 ) {
+			return BlockStart::none();
+		}
+
+		if ( $this->closesInlineOnFirstLine( $line ) ) {
+			return BlockStart::none();
+		}
+
+		return BlockStart::of( new TemplateCallBlockParser() )->at( $cursor );
+	}
+
+	/**
+	 * True when the braces balance within this line and non-space text follows
+	 * the closing `}}`, meaning the call belongs inline rather than as a block.
+	 */
+	private function closesInlineOnFirstLine( string $line ): bool {
+		$fromBraces = ltrim( $line, " \t" );
+		$call = TemplateBraces::matchLeadingCall( $fromBraces );
+
+		return $call !== null && trim( substr( $fromBraces, strlen( $call ) ) ) !== '';
+	}
+
+}
diff --git a/src/Application/CommonMark/TemplateCallNode.php b/src/Application/CommonMark/TemplateCallNode.php
new file mode 100644
index 0000000..69f369e
--- /dev/null
+++ b/src/Application/CommonMark/TemplateCallNode.php
@@ -0,0 +1,24 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Application\CommonMark;
+
+use League\CommonMark\Node\Inline\AbstractInline;
+
+/**
+ * AST node for an inline `{{...}}` call. Holds the raw wikitext (braces
+ * included); the expanded HTML is filled in by a later pipeline stage and
+ * stays null when no expander runs, degrading to escaped literal text.
+ */
+final class TemplateCallNode extends AbstractInline {
+
+	public ?string $expandedHtml = null;
+
+	public function __construct(
+		public readonly string $wikitext
+	) {
+		parent::__construct();
+	}
+
+}
diff --git a/src/Application/CommonMark/TemplateCallParser.php b/src/Application/CommonMark/TemplateCallParser.php
new file mode 100644
index 0000000..7743cfc
--- /dev/null
+++ b/src/Application/CommonMark/TemplateCallParser.php
@@ -0,0 +1,46 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Application\CommonMark;
+
+use League\CommonMark\Parser\Inline\InlineParserInterface;
+use League\CommonMark\Parser\Inline\InlineParserMatch;
+use League\CommonMark\Parser\InlineParserContext;
+
+/**
+ * Inline parser for `{{...}}` template calls that sit within a line of text.
+ * Captures the balanced brace span, handing nested calls and arguments to the
+ * expander untouched. Own-line block calls are handled by
+ * TemplateCallBlockStartParser; multi-line spans and `{{{...}}}` argument
+ * syntax fall through to literal text.
+ */
+final class TemplateCallParser implements InlineParserInterface {
+
+	public function getMatchDefinition(): InlineParserMatch {
+		return InlineParserMatch::string( '{{' );
+	}
+
+	public function parse( InlineParserContext $inlineContext ): bool {
+		$cursor = $inlineContext->getCursor();
+
+		// A preceding brace means we are inside a `{{{...}}}` run: leave it literal.
+		if ( $cursor->peek( -1 ) === '{' ) {
+			return false;
+		}
+
+		$wikitext = TemplateBraces::matchLeadingCall( $cursor->getRemainder() );
+
+		if ( $wikitext === null ) {
+			return false;
+		}
+
+		// advanceBy() counts characters, not bytes, so byte offsets must be
+		// converted, as in WikiLinkParser.
+		$cursor->advanceBy( mb_strlen( $wikitext, 'UTF-8' ) );
+		$inlineContext->getContainer()->appendChild( new TemplateCallNode( $wikitext ) );
+
+		return true;
+	}
+
+}
diff --git a/src/Application/CommonMark/TemplateCallRenderer.php b/src/Application/CommonMark/TemplateCallRenderer.php
new file mode 100644
index 0000000..af7b2af
--- /dev/null
+++ b/src/Application/CommonMark/TemplateCallRenderer.php
@@ -0,0 +1,32 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Application\CommonMark;
+
+use League\CommonMark\Node\Node;
+use League\CommonMark\Renderer\ChildNodeRendererInterface;
+use League\CommonMark\Renderer\NodeRendererInterface;
+use League\CommonMark\Util\Xml;
+
+/**
+ * Renders template-call nodes as the expander's trusted HTML. When no expansion
+ * ran (feature off, no page context, or an unbalanced block) the raw wikitext
+ * is shown escaped, mirroring how unresolved wikilinks degrade to literal text.
+ */
+final class TemplateCallRenderer implements NodeRendererInterface {
+
+	public function render( Node $node, ChildNodeRendererInterface $childRenderer ): string {
+		if ( $node instanceof TemplateCallNode ) {
+			return $node->expandedHtml ?? Xml::escape( $node->wikitext );
+		}
+
+		if ( $node instanceof TemplateCallBlock ) {
+			// The HTML renderer adds the trailing block separator itself.
+			return $node->expandedHtml ?? '<p>' . Xml::escape( $node->wikitext ) . '</p>';
+		}
+
+		return '';
+	}
+
+}
diff --git a/src/Application/MarkdownRenderer.php b/src/Application/MarkdownRenderer.php
index c30f9c7..0dde235 100644
--- a/src/Application/MarkdownRenderer.php
+++ b/src/Application/MarkdownRenderer.php
@@ -31,6 +31,11 @@
 use ProfessionalWiki\NativeMarkdown\Application\CommonMark\FileEmbedNode;
 use ProfessionalWiki\NativeMarkdown\Application\CommonMark\FileEmbedNodeRenderer;
 use ProfessionalWiki\NativeMarkdown\Application\CommonMark\ImageLinkRenderer;
+use ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallBlock;
+use ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallBlockStartParser;
+use ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallNode;
+use ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallParser;
+use ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallRenderer;
 use ProfessionalWiki\NativeMarkdown\Application\CommonMark\TocPlaceholder;
 use ProfessionalWiki\NativeMarkdown\Application\CommonMark\TocPlaceholderRenderer;
 use ProfessionalWiki\NativeMarkdown\Application\CommonMark\WikiLinkNode;
@@ -45,6 +50,7 @@
 final class MarkdownRenderer {
 
 	private const WIKI_LINK_PARSER_PRIORITY = 100;
+	private const TEMPLATE_CALL_PARSER_PRIORITY = 100;
 	private const RENDERER_OVERRIDE_PRIORITY = 10;
 
 	private MarkdownParser $parser;
@@ -58,9 +64,15 @@ public function __construct(
 		bool $allowExternalImages,
 		int $maxNestingLevel,
 		private readonly ?string $tocPlaceholderHtml,
-		bool $noFollowExternalLinks
+		bool $noFollowExternalLinks,
+		bool $templateTransclusion
 	) {
-		$environment = $this->newEnvironment( $allowExternalImages, $maxNestingLevel, $noFollowExternalLinks );
+		$environment = $this->newEnvironment(
+			$allowExternalImages,
+			$maxNestingLevel,
+			$noFollowExternalLinks,
+			$templateTransclusion
+		);
 
 		$this->parser = new MarkdownParser( $environment );
 		$this->htmlRenderer = new HtmlRenderer( $environment );
@@ -70,7 +82,8 @@ public function __construct(
 	private function newEnvironment(
 		bool $allowExternalImages,
 		int $maxNestingLevel,
-		bool $noFollowExternalLinks
+		bool $noFollowExternalLinks,
+		bool $templateTransclusion
 	): Environment {
 		$environment = new Environment( [
 			'html_input' => HtmlFilter::ESCAPE,
@@ -106,6 +119,17 @@ private function newEnvironment(
 			);
 		}
 
+		// Registered only when the feature is on, so with it off `{{...}}` is
+		// never recognized and output stays identical to plain markdown.
+		if ( $templateTransclusion ) {
+			$templateRenderer = new TemplateCallRenderer();
+
+			$environment->addInlineParser( new TemplateCallParser(), self::TEMPLATE_CALL_PARSER_PRIORITY );
+			$environment->addBlockStartParser( new TemplateCallBlockStartParser() );
+			$environment->addRenderer( TemplateCallNode::class, $templateRenderer );
+			$environment->addRenderer( TemplateCallBlock::class, $templateRenderer );
+		}
+
 		return $environment;
 	}
 
@@ -116,20 +140,36 @@ private function newEnvironment(
 	 * link and file adapters) propagate — falling back on those would cache
 	 * degraded output and empty the page's link tables.
 	 */
-	public function render( string $markdown, bool $generateHtml ): RenderedMarkdown {
+	public function render(
+		string $markdown,
+		bool $generateHtml,
+		?TemplateExpander $templateExpander = null
+	): RenderedMarkdown {
 		try {
-			return $this->renderDocument( $markdown, $generateHtml );
+			return $this->renderDocument( $markdown, $generateHtml, $templateExpander );
 		} catch ( CommonMarkException ) {
 			return $this->escapedSourceFallback( $markdown, $generateHtml );
 		}
 	}
 
-	private function renderDocument( string $markdown, bool $generateHtml ): RenderedMarkdown {
+	private function renderDocument(
+		string $markdown,
+		bool $generateHtml,
+		?TemplateExpander $templateExpander
+	): RenderedMarkdown {
 		[ $frontMatter, $content ] = $this->extractFrontMatter( $markdown );
 
 		$document = $this->parser->parse( $content );
 
 		[ $links, $categories, $files ] = $this->resolveWikiLinks( $document );
+
+		// Runs regardless of $generateHtml: expansion records each template's
+		// wiki dependencies, and a metadata-only parse that skipped it would
+		// leave the link tables incomplete and break template-edit invalidation.
+		if ( $templateExpander !== null ) {
+			$this->expandTemplateCalls( $document, $templateExpander );
+		}
+
 		$this->preloadLinkExistence( $links );
 		$this->preloadFileLookups( $files, $generateHtml );
 		$sections = $this->processHeadings( $document );
@@ -145,6 +185,38 @@ private function renderDocument( string $markdown, bool $generateHtml ): Rendere
 		);
 	}
 
+	/**
+	 * Replaces the raw wikitext of each template call with the expander's HTML.
+	 * Unbalanced block calls are skipped and shown by the renderer as literal
+	 * text rather than fed to the expander.
+	 */
+	private function expandTemplateCalls( Document $document, TemplateExpander $templateExpander ): void {
+		foreach ( $this->templateCallNodes( $document ) as $node ) {
+			if ( $node instanceof TemplateCallBlock && !$node->balanced ) {
+				continue;
+			}
+
+			$node->expandedHtml = $templateExpander->expand(
+				new TemplateCall( $node->wikitext, $node instanceof TemplateCallBlock )
+			);
+		}
+	}
+
+	/**
+	 * @return array<TemplateCallNode|TemplateCallBlock>
+	 */
+	private function templateCallNodes( Document $document ): array {
+		$nodes = [];
+
+		foreach ( $document->iterator() as $node ) {
+			if ( $node instanceof TemplateCallNode || $node instanceof TemplateCallBlock ) {
+				$nodes[] = $node;
+			}
+		}
+
+		return $nodes;
+	}
+
 	/**
 	 * The visible words of the document for the search index: markdown and wiki
 	 * markup removed, front matter and category assignments excluded. No HTML is
@@ -197,6 +269,8 @@ private function nodeSearchText( Node $node ): string {
 		return match ( true ) {
 			$node instanceof WikiLinkNode => ' ' . $node->displayLabel() . ' ',
 			$node instanceof FileEmbedNode => ' ' . ( $node->embed->caption ?? $node->embed->altText ?? '' ) . ' ',
+			$node instanceof TemplateCallNode => '',
+			$node instanceof TemplateCallBlock => '',
 			$node instanceof StringContainerInterface => $node->getLiteral(),
 			$node instanceof Newline => ' ',
 			default => ''
@@ -483,6 +557,7 @@ private function plainText( Node $node ): string {
 			$text .= match ( true ) {
 				$child instanceof WikiLinkNode => $child->displayLabel(),
 				$child instanceof FileEmbedNode => '',
+				$child instanceof TemplateCallNode => '',
 				$child instanceof RawMarkupContainerInterface => '',
 				$child instanceof StringContainerInterface => $child->getLiteral(),
 				$child instanceof Newline => ' ',
diff --git a/src/Application/TemplateCall.php b/src/Application/TemplateCall.php
new file mode 100644
index 0000000..5a26184
--- /dev/null
+++ b/src/Application/TemplateCall.php
@@ -0,0 +1,20 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Application;
+
+/**
+ * A `{{...}}` call found on a markdown page, carrying the raw wikitext to expand
+ * (braces included) and whether it stands as its own block or sits inline in text.
+ * The wikitext is opaque here: only the TemplateExpander port interprets it.
+ */
+final class TemplateCall {
+
+	public function __construct(
+		public readonly string $wikitext,
+		public readonly bool $isBlock
+	) {
+	}
+
+}
diff --git a/src/Application/TemplateExpander.php b/src/Application/TemplateExpander.php
new file mode 100644
index 0000000..128ca97
--- /dev/null
+++ b/src/Application/TemplateExpander.php
@@ -0,0 +1,25 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Application;
+
+/**
+ * Turns a `{{...}}` call into safe, ready-to-embed HTML.
+ *
+ * Expansion has a side effect the caller relies on but cannot see: the
+ * implementation records the wiki dependencies of the call (templates,
+ * links, images, categories) against the render in progress, so the page
+ * is reparsed when a transcluded template changes. Infrastructure failures
+ * propagate rather than degrading to literal text, matching MarkdownRenderer:
+ * caching a page with empty dependency tables would break that invalidation.
+ */
+interface TemplateExpander {
+
+	/**
+	 * @return string Safe HTML. Block calls yield block-level HTML; inline
+	 *   calls yield inline HTML with no surrounding paragraph.
+	 */
+	public function expand( TemplateCall $call ): string;
+
+}
diff --git a/src/EntryPoints/MarkdownContentHandler.php b/src/EntryPoints/MarkdownContentHandler.php
index be0fc54..e48b42d 100644
--- a/src/EntryPoints/MarkdownContentHandler.php
+++ b/src/EntryPoints/MarkdownContentHandler.php
@@ -120,9 +120,18 @@ protected function fillParserOutput( Content $content, ContentParseParams $cpoPa
 			return;
 		}
 
-		$rendered = NativeMarkdownExtension::getInstance()->getMarkdownRenderer()->render(
+		$extension = NativeMarkdownExtension::getInstance();
+
+		$templateExpander = $extension->newTemplateExpander(
+			$cpoParams->getPage(),
+			$cpoParams->getParserOptions(),
+			$cpoParams->getRevId()
+		);
+
+		$rendered = $extension->getMarkdownRenderer()->render(
 			$text,
-			$cpoParams->getGenerateHtml()
+			$cpoParams->getGenerateHtml(),
+			$templateExpander
 		);
 
 		$output->setFromParserOptions( $cpoParams->getParserOptions() );
@@ -132,6 +141,13 @@ protected function fillParserOutput( Content $content, ContentParseParams $cpoPa
 		$this->registerFiles( $output, $rendered );
 		$this->registerExternalLinks( $output, $rendered );
 		$this->registerFrontMatter( $output, $rendered );
+
+		if ( $templateExpander !== null ) {
+			$templateExpander->mergeInto( $output );
+		}
+
+		// Last, so the page's table of contents comes from its own markdown
+		// headings, not from headings inside transcluded templates.
 		$this->registerSections( $output, $rendered );
 
 		$output->setRawText( $cpoParams->getGenerateHtml() ? $rendered->html : null );
@@ -192,16 +208,17 @@ private function registerFrontMatter( ParserOutput $output, RenderedMarkdown $re
 		}
 	}
 
+	/**
+	 * Sets the table of contents from the page's own markdown headings,
+	 * authoritatively: it overwrites any TOCData and SHOW_TOC flag a transcluded
+	 * template merged in, so the contents list never lists template headings.
+	 */
 	private function registerSections( ParserOutput $output, RenderedMarkdown $rendered ): void {
-		if ( $rendered->sections === [] ) {
-			return;
-		}
-
 		$output->setTOCData( $this->buildTocData( $rendered->sections ) );
-
-		if ( count( $rendered->sections ) >= self::TOC_SECTION_THRESHOLD ) {
-			$output->setOutputFlag( ParserOutputFlags::SHOW_TOC );
-		}
+		$output->setOutputFlag(
+			ParserOutputFlags::SHOW_TOC,
+			count( $rendered->sections ) >= self::TOC_SECTION_THRESHOLD
+		);
 	}
 
 	/**
diff --git a/src/NativeMarkdownExtension.php b/src/NativeMarkdownExtension.php
index 430a8f4..5e63fcd 100644
--- a/src/NativeMarkdownExtension.php
+++ b/src/NativeMarkdownExtension.php
@@ -5,12 +5,15 @@
 namespace ProfessionalWiki\NativeMarkdown;
 
 use MediaWiki\MediaWikiServices;
+use MediaWiki\Page\PageReference;
 use MediaWiki\Parser\Parser;
+use MediaWiki\Parser\ParserOptions;
 use ProfessionalWiki\NativeMarkdown\Application\MarkdownDefaultPolicy;
 use ProfessionalWiki\NativeMarkdown\Application\MarkdownRenderer;
 use ProfessionalWiki\NativeMarkdown\Application\RedirectSyntax;
 use ProfessionalWiki\NativeMarkdown\Persistence\MediaWikiFileEmbedRenderer;
 use ProfessionalWiki\NativeMarkdown\Persistence\MediaWikiPageLinkRenderer;
+use ProfessionalWiki\NativeMarkdown\Persistence\MediaWikiTemplateExpander;
 use ProfessionalWiki\NativeMarkdown\Persistence\MediaWikiTitleParser;
 
 /**
@@ -66,7 +69,8 @@ private function newMarkdownRenderer(): MarkdownRenderer {
 			allowExternalImages: (bool)$services->getMainConfig()->get( 'NativeMarkdownAllowExternalImages' ),
 			maxNestingLevel: self::MAX_NESTING_LEVEL,
 			tocPlaceholderHtml: Parser::TOC_PLACEHOLDER,
-			noFollowExternalLinks: (bool)$services->getMainConfig()->get( 'NoFollowLinks' )
+			noFollowExternalLinks: (bool)$services->getMainConfig()->get( 'NoFollowLinks' ),
+			templateTransclusion: (bool)$services->getMainConfig()->get( 'NativeMarkdownTemplateTransclusion' )
 		);
 	}
 
@@ -82,6 +86,30 @@ private function defaultThumbnailWidth( MediaWikiServices $services ): int {
 		return (int)( $thumbLimits[$defaultThumbSize] ?? 300 );
 	}
 
+	/**
+	 * The expander a single page render uses to transclude its template calls,
+	 * or null when transclusion is disabled. Built per render because it carries
+	 * that render's page, options and revision.
+	 */
+	public function newTemplateExpander(
+		PageReference $page,
+		ParserOptions $parserOptions,
+		?int $revisionId
+	): ?MediaWikiTemplateExpander {
+		$services = MediaWikiServices::getInstance();
+
+		if ( !$services->getMainConfig()->get( 'NativeMarkdownTemplateTransclusion' ) ) {
+			return null;
+		}
+
+		return new MediaWikiTemplateExpander(
+			parserFactory: $services->getParserFactory(),
+			page: $page,
+			parserOptions: $parserOptions,
+			revisionId: $revisionId
+		);
+	}
+
 	public function newRedirectSyntax(): RedirectSyntax {
 		return new RedirectSyntax(
 			magicWordSynonyms: MediaWikiServices::getInstance()
diff --git a/src/Persistence/MediaWikiTemplateExpander.php b/src/Persistence/MediaWikiTemplateExpander.php
new file mode 100644
index 0000000..49276eb
--- /dev/null
+++ b/src/Persistence/MediaWikiTemplateExpander.php
@@ -0,0 +1,97 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Persistence;
+
+use MediaWiki\Page\PageReference;
+use MediaWiki\Parser\Parser;
+use MediaWiki\Parser\ParserFactory;
+use MediaWiki\Parser\ParserOptions;
+use MediaWiki\Parser\ParserOutput;
+use ProfessionalWiki\NativeMarkdown\Application\TemplateCall;
+use ProfessionalWiki\NativeMarkdown\Application\TemplateExpander;
+
+/**
+ * Expands `{{...}}` calls by delegating to MediaWiki's wikitext parser, so
+ * templates, parser functions, magic words, dependency tracking, and recursion
+ * limits all come from core. One Parser is reused across a page's calls; each
+ * child ParserOutput is kept and folded into the page's output by mergeInto(),
+ * which is how the page gets reparsed when a transcluded template changes.
+ *
+ * Built fresh per page render (never memoized) because it carries that render's
+ * page, options and revision, and accumulates that render's child outputs.
+ */
+final class MediaWikiTemplateExpander implements TemplateExpander {
+
+	private ?Parser $parser = null;
+	private ParserOptions $childOptions;
+
+	/** @var ParserOutput[] */
+	private array $childOutputs = [];
+
+	public function __construct(
+		private readonly ParserFactory $parserFactory,
+		private readonly PageReference $page,
+		ParserOptions $parserOptions,
+		private readonly ?int $revisionId
+	) {
+		// A private copy so each child parse repoints its own option-usage watcher
+		// instead of the one core registered on the page's ParserOptions (which
+		// points at the page ParserOutput). The options the templates read still
+		// reach the page output through mergeInternalMetaDataFrom() in mergeInto().
+		$this->childOptions = clone $parserOptions;
+	}
+
+	public function expand( TemplateCall $call ): string {
+		$output = $this->parser()->parse(
+			$call->wikitext,
+			$this->page,
+			$this->childOptions,
+			true,
+			true,
+			$this->revisionId
+		);
+
+		$this->childOutputs[] = $output;
+
+		$html = $output->runOutputPipeline(
+			$this->childOptions,
+			[
+				// The page composes its own wrapper, ToC and section edit links;
+				// keeping the fragment free of them avoids per-user, per-skin
+				// artifacts being frozen into the page's parser cache.
+				'unwrap' => true,
+				'allowTOC' => false,
+				'enableSectionEditLinks' => false,
+			]
+		)->getContentHolderText();
+
+		// A block call keeps the parser's block HTML; an inline call drops the
+		// paragraph the parser wraps loose text in so it flows within the line.
+		return $call->isBlock ? $html : Parser::stripOuterParagraph( $html );
+	}
+
+	/**
+	 * Folds every child parse's metadata into the page's output using the same
+	 * merges core uses to combine content slots (RevisionRenderer), plus the
+	 * cache expiry no merge method carries, so templatelinks/imagelinks/
+	 * categorylinks, the modules templates need, cache-varying options and TTLs
+	 * are all recorded against the page.
+	 */
+	public function mergeInto( ParserOutput $pageOutput ): void {
+		foreach ( $this->childOutputs as $childOutput ) {
+			$pageOutput->mergeInternalMetaDataFrom( $childOutput );
+			$pageOutput->mergeTrackingMetaDataFrom( $childOutput );
+			$pageOutput->mergeHtmlMetaDataFrom( $childOutput );
+			$pageOutput->updateCacheExpiry( $childOutput->getCacheExpiry() );
+		}
+	}
+
+	private function parser(): Parser {
+		$this->parser ??= $this->parserFactory->create();
+
+		return $this->parser;
+	}
+
+}
diff --git a/tests/phpunit/Application/FixtureRenderingTest.php b/tests/phpunit/Application/FixtureRenderingTest.php
index 4380965..639433f 100644
--- a/tests/phpunit/Application/FixtureRenderingTest.php
+++ b/tests/phpunit/Application/FixtureRenderingTest.php
@@ -48,7 +48,8 @@ private function render( string $markdown ): string {
 			allowExternalImages: false,
 			maxNestingLevel: 100,
 			tocPlaceholderHtml: null,
-			noFollowExternalLinks: true
+			noFollowExternalLinks: true,
+			templateTransclusion: false
 		);
 
 		return $renderer->render( $markdown, generateHtml: true )->html;
diff --git a/tests/phpunit/Application/MarkdownRendererTest.php b/tests/phpunit/Application/MarkdownRendererTest.php
index d5b4b6c..bf17ac7 100644
--- a/tests/phpunit/Application/MarkdownRendererTest.php
+++ b/tests/phpunit/Application/MarkdownRendererTest.php
@@ -9,8 +9,10 @@
 use ProfessionalWiki\NativeMarkdown\Application\PageLinkRenderer;
 use ProfessionalWiki\NativeMarkdown\Application\RenderedMarkdown;
 use ProfessionalWiki\NativeMarkdown\Application\Section;
+use ProfessionalWiki\NativeMarkdown\Application\TemplateExpander;
 use ProfessionalWiki\NativeMarkdown\Tests\TestDoubles\FakeFileEmbedRenderer;
 use ProfessionalWiki\NativeMarkdown\Tests\TestDoubles\FakePageLinkRenderer;
+use ProfessionalWiki\NativeMarkdown\Tests\TestDoubles\FakeTemplateExpander;
 use ProfessionalWiki\NativeMarkdown\Tests\TestDoubles\FakeWikiTitleParser;
 use ProfessionalWiki\NativeMarkdown\Tests\TestDoubles\RecordingPageLinkRenderer;
 use ProfessionalWiki\NativeMarkdown\Tests\TestDoubles\SpyPageLinkRenderer;
@@ -28,13 +30,22 @@
  * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\ExternalLinkRenderer
  * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\TocPlaceholder
  * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\TocPlaceholderRenderer
+ * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallParser
+ * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallBlockStartParser
+ * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallBlockParser
+ * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallNode
+ * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallBlock
+ * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateCallRenderer
+ * @covers \ProfessionalWiki\NativeMarkdown\Application\CommonMark\TemplateBraces
+ * @covers \ProfessionalWiki\NativeMarkdown\Application\TemplateCall
  */
 class MarkdownRendererTest extends TestCase {
 
 	private function newRenderer(
 		bool $allowExternalImages = false,
 		?PageLinkRenderer $pageLinkRenderer = null,
-		?string $tocPlaceholderHtml = null
+		?string $tocPlaceholderHtml = null,
+		bool $templateTransclusion = false
 	): MarkdownRenderer {
 		return new MarkdownRenderer(
 			titleParser: new FakeWikiTitleParser(),
@@ -43,7 +54,8 @@ private function newRenderer(
 			allowExternalImages: $allowExternalImages,
 			maxNestingLevel: 100,
 			tocPlaceholderHtml: $tocPlaceholderHtml,
-			noFollowExternalLinks: true
+			noFollowExternalLinks: true,
+			templateTransclusion: $templateTransclusion
 		);
 	}
 
@@ -52,10 +64,12 @@ private function render(
 		bool $allowExternalImages = false,
 		?PageLinkRenderer $pageLinkRenderer = null,
 		bool $generateHtml = true,
-		?string $tocPlaceholderHtml = null
+		?string $tocPlaceholderHtml = null,
+		bool $templateTransclusion = false,
+		?TemplateExpander $templateExpander = null
 	): RenderedMarkdown {
-		return $this->newRenderer( $allowExternalImages, $pageLinkRenderer, $tocPlaceholderHtml )
-			->render( $markdown, $generateHtml );
+		return $this->newRenderer( $allowExternalImages, $pageLinkRenderer, $tocPlaceholderHtml, $templateTransclusion )
+			->render( $markdown, $generateHtml, $templateExpander );
 	}
 
 	private function extractPlainText( string $markdown ): string {
@@ -438,7 +452,8 @@ public function testFileLookupsArePreloadedInOneBatchBeforeRendering(): void {
 			allowExternalImages: false,
 			maxNestingLevel: 100,
 			tocPlaceholderHtml: null,
-			noFollowExternalLinks: true
+			noFollowExternalLinks: true,
+			templateTransclusion: false
 		);
 
 		$renderer->render( "[[File:First.png]] and [[File:Second.png]]", true );
@@ -821,4 +836,207 @@ public function testMetadataOnlyRenderSkipsHtmlAndLinkRendering(): void {
 		$this->assertSame( 0, $spy->renderedLinkCount );
 	}
 
+	public function testTemplateCallsAreLiteralTextWhenTransclusionDisabled(): void {
+		$expander = new FakeTemplateExpander();
+
+		$result = $this->render( 'See {{Greeting}} here', templateExpander: $expander );
+
+		$this->assertSame( "<p>See {{Greeting}} here</p>\n", $result->html );
+		$this->assertSame( [], $expander->calls );
+	}
+
+	public function testInlineTemplateCallIsExpandedAndInjectedRaw(): void {
+		$expander = new FakeTemplateExpander();
+
+		$result = $this->render(
+			'See {{Greeting}} here',
+			templateTransclusion: true,
+			templateExpander: $expander
+		);
+
+		$this->assertSame(
+			"<p>See <span class=\"fake-expanded\">{{Greeting}}</span> here</p>\n",
+			$result->html
+		);
+	}
+
+	public function testInlineTemplateCallPassesWikitextAndInlineFlagToExpander(): void {
+		$expander = new FakeTemplateExpander();
+
+		$this->render( 'See {{Greeting|Ada}} here', templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertCount( 1, $expander->calls );
+		$this->assertSame( '{{Greeting|Ada}}', $expander->calls[0]->wikitext );
+		$this->assertFalse( $expander->calls[0]->isBlock );
+	}
+
+	public function testBlockTemplateCallOnItsOwnLineIsNotWrappedInParagraph(): void {
+		$expander = new FakeTemplateExpander();
+
+		$result = $this->render( '{{Infobox}}', templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertStringContainsString( '<div class="fake-expanded">{{Infobox}}</div>', $result->html );
+		$this->assertStringNotContainsString( '<p>', $result->html );
+		$this->assertTrue( $expander->calls[0]->isBlock );
+	}
+
+	public function testMultiLineBlockTemplateIsCapturedAsOneCall(): void {
+		$expander = new FakeTemplateExpander();
+		$wikitext = "{{Infobox person\n| name = Ada\n| born = 1815\n}}";
+
+		$this->render( $wikitext, templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertCount( 1, $expander->calls );
+		$this->assertSame( $wikitext, $expander->calls[0]->wikitext );
+		$this->assertTrue( $expander->calls[0]->isBlock );
+	}
+
+	public function testMultiLineBlockTemplateKeepsBlankParameterLines(): void {
+		$expander = new FakeTemplateExpander();
+		$wikitext = "{{Infobox\n| a = 1\n\n| b = 2\n}}";
+
+		$this->render( $wikitext, templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertSame( $wikitext, $expander->calls[0]->wikitext );
+	}
+
+	public function testNestedTemplateBecomesOneCall(): void {
+		$expander = new FakeTemplateExpander();
+
+		$this->render( 'X {{outer|{{inner}}}} Y', templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertCount( 1, $expander->calls );
+		$this->assertSame( '{{outer|{{inner}}}}', $expander->calls[0]->wikitext );
+	}
+
+	public function testTripleBraceArgumentSyntaxStaysLiteral(): void {
+		$expander = new FakeTemplateExpander();
+
+		$result = $this->render( 'Value: {{{param}}} here', templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertSame( [], $expander->calls );
+		$this->assertStringContainsString( '{{{param}}}', $result->html );
+	}
+
+	public function testTemplateCallWithoutExpanderDegradesToEscapedLiteral(): void {
+		$result = $this->render( '{{Infobox}}', templateTransclusion: true );
+
+		$this->assertSame( "<p>{{Infobox}}</p>\n", $result->html );
+	}
+
+	public function testBalancedCallWithTrailingTextIsInlineNotBlock(): void {
+		$expander = new FakeTemplateExpander();
+
+		$result = $this->render( '{{Foo}} and more', templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertFalse( $expander->calls[0]->isBlock );
+		$this->assertSame(
+			"<p><span class=\"fake-expanded\">{{Foo}}</span> and more</p>\n",
+			$result->html
+		);
+	}
+
+	public function testUnclosedBlockTemplateDegradesToLiteralInsteadOfExpanding(): void {
+		$expander = new FakeTemplateExpander();
+
+		$result = $this->render(
+			"{{Unclosed\nmore body text\nand still more",
+			templateTransclusion: true,
+			templateExpander: $expander
+		);
+
+		$this->assertSame( [], $expander->calls );
+		$this->assertStringContainsString( '{{Unclosed', $result->html );
+	}
+
+	public function testTemplateCallInsideInlineCodeStaysLiteral(): void {
+		$expander = new FakeTemplateExpander();
+
+		$result = $this->render( 'Use `{{Foo}}` in code', templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertSame( [], $expander->calls );
+		$this->assertStringContainsString( '<code>{{Foo}}</code>', $result->html );
+	}
+
+	public function testTemplateCallInsideFencedCodeStaysLiteral(): void {
+		$expander = new FakeTemplateExpander();
+
+		$result = $this->render(
+			"```\n{{Foo}}\n```",
+			templateTransclusion: true,
+			templateExpander: $expander
+		);
+
+		$this->assertSame( [], $expander->calls );
+		$this->assertStringContainsString( '{{Foo}}', $result->html );
+	}
+
+	public function testBackslashEscapedBracesStayLiteral(): void {
+		$expander = new FakeTemplateExpander();
+
+		$result = $this->render( 'Literal \\{\\{Foo}} here', templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertSame( [], $expander->calls );
+		$this->assertStringContainsString( '{{Foo}}', $result->html );
+	}
+
+	public function testTemplateCallInHeadingContributesNothingToAnchor(): void {
+		$result = $this->render(
+			'## Section {{Foo}}',
+			templateTransclusion: true,
+			templateExpander: new FakeTemplateExpander()
+		);
+
+		$this->assertStringNotContainsString( 'Foo', $result->sections[0]->anchor );
+		$this->assertStringNotContainsString( '{', $result->sections[0]->anchor );
+	}
+
+	public function testSearchTextExcludesTemplateWikitext(): void {
+		$text = $this->newRenderer( templateTransclusion: true )
+			->extractPlainText( 'Body {{Foo|bar}} words' );
+
+		$this->assertStringNotContainsString( 'Foo', $text );
+		$this->assertStringNotContainsString( '{{', $text );
+		$this->assertStringContainsString( 'Body', $text );
+		$this->assertStringContainsString( 'words', $text );
+	}
+
+	public function testTemplateExpansionRunsEvenWhenNotGeneratingHtml(): void {
+		$expander = new FakeTemplateExpander();
+
+		$this->render(
+			'{{Infobox}}',
+			generateHtml: false,
+			templateTransclusion: true,
+			templateExpander: $expander
+		);
+
+		$this->assertCount( 1, $expander->calls );
+	}
+
+	public function testEachTemplateCallOnItsOwnLineIsExpanded(): void {
+		$expander = new FakeTemplateExpander();
+
+		$this->render( "{{First}}\n\n{{Second}}", templateTransclusion: true, templateExpander: $expander );
+
+		$this->assertSame(
+			[ '{{First}}', '{{Second}}' ],
+			array_map( static fn ( $call ) => $call->wikitext, $expander->calls )
+		);
+	}
+
+	public function testTemplateCallInTableCellUsesEscapedPipeForArguments(): void {
+		$expander = new FakeTemplateExpander();
+
+		$this->render(
+			"| Col |\n|---|\n| {{Greeting\\|Ada}} |",
+			templateTransclusion: true,
+			templateExpander: $expander
+		);
+
+		$this->assertCount( 1, $expander->calls );
+		$this->assertSame( '{{Greeting|Ada}}', $expander->calls[0]->wikitext );
+		$this->assertFalse( $expander->calls[0]->isBlock );
+	}
+
 }
diff --git a/tests/phpunit/Application/XssSafetyTest.php b/tests/phpunit/Application/XssSafetyTest.php
index 0c2290d..bea904a 100644
--- a/tests/phpunit/Application/XssSafetyTest.php
+++ b/tests/phpunit/Application/XssSafetyTest.php
@@ -94,7 +94,8 @@ private function render( string $markdown, bool $allowExternalImages = false ):
 			allowExternalImages: $allowExternalImages,
 			maxNestingLevel: 100,
 			tocPlaceholderHtml: null,
-			noFollowExternalLinks: true
+			noFollowExternalLinks: true,
+			templateTransclusion: false
 		);
 
 		return $renderer->render( $markdown, generateHtml: true )->html;
diff --git a/tests/phpunit/EntryPoints/MarkdownTransclusionTest.php b/tests/phpunit/EntryPoints/MarkdownTransclusionTest.php
new file mode 100644
index 0000000..bff31d2
--- /dev/null
+++ b/tests/phpunit/EntryPoints/MarkdownTransclusionTest.php
@@ -0,0 +1,126 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Tests\EntryPoints;
+
+use MediaWiki\Page\PageReferenceValue;
+use MediaWiki\Parser\ParserOutput;
+use MediaWikiIntegrationTestCase;
+use ProfessionalWiki\NativeMarkdown\EntryPoints\MarkdownContent;
+
+/**
+ * End-to-end template transclusion on markdown pages, exercised through the
+ * real content-render path and the MediaWiki parser.
+ *
+ * @covers \ProfessionalWiki\NativeMarkdown\EntryPoints\MarkdownContentHandler
+ * @covers \ProfessionalWiki\NativeMarkdown\Persistence\MediaWikiTemplateExpander
+ * @covers \ProfessionalWiki\NativeMarkdown\NativeMarkdownExtension
+ * @group Database
+ */
+class MarkdownTransclusionTest extends MediaWikiIntegrationTestCase {
+
+	private const PAGE = 'NativeMarkdownTransclusionPage';
+
+	protected function setUp(): void {
+		parent::setUp();
+		$this->overrideConfigValue( 'NativeMarkdownTemplateTransclusion', true );
+	}
+
+	private function getParserOutput( string $markdown, bool $generateHtml = true ): ParserOutput {
+		return $this->getServiceContainer()->getContentRenderer()->getParserOutput(
+			new MarkdownContent( $markdown ),
+			PageReferenceValue::localReference( NS_MAIN, self::PAGE ),
+			null,
+			null,
+			[ 'generate-html' => $generateHtml ]
+		);
+	}
+
+	public function testTranscludedTemplateRendersInPageHtml(): void {
+		$this->editPage( 'Template:Greeting', 'Hello from the template' );
+
+		$output = $this->getParserOutput( 'Intro {{Greeting}} outro' );
+
+		$this->assertStringContainsString( 'Hello from the template', $output->getRawText() );
+	}
+
+	public function testBlockTemplateRendersTableFromWikitext(): void {
+		$this->editPage( 'Template:Infobox', "{| class=\"wikitable\"\n| Cell content\n|}" );
+
+		$output = $this->getParserOutput( '{{Infobox}}' );
+
+		$this->assertStringContainsString( '<table', $output->getRawText() );
+		$this->assertStringContainsString( 'Cell content', $output->getRawText() );
+	}
+
+	public function testTransclusionRecordsTemplateDependency(): void {
+		$this->editPage( 'Template:Greeting', 'Hello' );
+
+		$output = $this->getParserOutput( '{{Greeting}}' );
+
+		$this->assertArrayHasKey( 'Greeting', $output->getTemplates()[NS_TEMPLATE] ?? [] );
+	}
+
+	public function testTemplateDependencyIsRecordedEvenWithoutHtml(): void {
+		$this->editPage( 'Template:Greeting', 'Hello' );
+
+		$output = $this->getParserOutput( '{{Greeting}}', generateHtml: false );
+
+		$this->assertArrayHasKey( 'Greeting', $output->getTemplates()[NS_TEMPLATE] ?? [] );
+	}
+
+	public function testCategoryAddedByTemplateIsRegisteredOnThePage(): void {
+		$this->editPage( 'Template:Categoriser', '[[Category:From Template]]' );
+
+		$output = $this->getParserOutput( 'Body {{Categoriser}}' );
+
+		$this->assertContains( 'From_Template', $output->getCategoryNames() );
+	}
+
+	public function testTemplateArgumentHtmlIsSanitized(): void {
+		$this->editPage( 'Template:Echo', '{{{1}}}' );
+
+		$output = $this->getParserOutput( '{{Echo|<script>alert(1)</script>}}' );
+
+		$this->assertStringNotContainsString( '<script>alert', $output->getRawText() );
+	}
+
+	public function testTemplateHeadingsDoNotAppearInThePageTableOfContents(): void {
+		$this->editPage( 'Template:Sections', "== Template Heading ==\nbody" );
+
+		$output = $this->getParserOutput( "# Real Heading\n\n{{Sections}}" );
+
+		$this->assertNotContains( 'Template_Heading', $this->tocAnchors( $output ) );
+	}
+
+	public function testTemplateHeadingsAreAbsentFromToCWhenThePageHasNoHeadings(): void {
+		$this->editPage( 'Template:Sections', "== Template Heading ==\nbody" );
+
+		$output = $this->getParserOutput( "Intro paragraph, no headings of its own.\n\n{{Sections}}" );
+
+		$this->assertNotContains( 'Template_Heading', $this->tocAnchors( $output ) );
+	}
+
+	/**
+	 * @return string[]
+	 */
+	private function tocAnchors( ParserOutput $output ): array {
+		return array_map(
+			static fn ( $section ) => $section->anchor,
+			$output->getTOCData()?->getSections() ?? []
+		);
+	}
+
+	public function testTemplateCallIsLiteralWhenTransclusionDisabled(): void {
+		$this->overrideConfigValue( 'NativeMarkdownTemplateTransclusion', false );
+		$this->editPage( 'Template:Greeting', 'Hello from the template' );
+
+		$output = $this->getParserOutput( '{{Greeting}}' );
+
+		$this->assertStringContainsString( '{{Greeting}}', $output->getRawText() );
+		$this->assertStringNotContainsString( 'Hello from the template', $output->getRawText() );
+		$this->assertSame( [], $output->getTemplates() );
+	}
+
+}
diff --git a/tests/phpunit/Persistence/MediaWikiTemplateExpanderTest.php b/tests/phpunit/Persistence/MediaWikiTemplateExpanderTest.php
new file mode 100644
index 0000000..6e3b561
--- /dev/null
+++ b/tests/phpunit/Persistence/MediaWikiTemplateExpanderTest.php
@@ -0,0 +1,93 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Tests\Persistence;
+
+use MediaWiki\Page\PageReferenceValue;
+use MediaWiki\Parser\ParserOptions;
+use MediaWiki\Parser\ParserOutput;
+use MediaWikiIntegrationTestCase;
+use ProfessionalWiki\NativeMarkdown\Application\TemplateCall;
+use ProfessionalWiki\NativeMarkdown\Persistence\MediaWikiTemplateExpander;
+
+/**
+ * @covers \ProfessionalWiki\NativeMarkdown\Persistence\MediaWikiTemplateExpander
+ * @group Database
+ */
+class MediaWikiTemplateExpanderTest extends MediaWikiIntegrationTestCase {
+
+	private function newExpander(): MediaWikiTemplateExpander {
+		return new MediaWikiTemplateExpander(
+			$this->getServiceContainer()->getParserFactory(),
+			PageReferenceValue::localReference( NS_MAIN, 'ExpanderTestPage' ),
+			ParserOptions::newFromAnon(),
+			null
+		);
+	}
+
+	public function testBlockCallKeepsTheParagraphAroundLooseText(): void {
+		$this->editPage( 'Template:Box', 'Box body text' );
+
+		$html = $this->newExpander()->expand( new TemplateCall( '{{Box}}', true ) );
+
+		$this->assertStringContainsString( 'Box body text', $html );
+		// Loose text keeps the parser's paragraph, unlike an inline call.
+		$this->assertStringContainsString( '<p>', $html );
+	}
+
+	public function testBlockCallRendersWikitableFromTemplate(): void {
+		$this->editPage( 'Template:Infobox', "{| class=\"wikitable\"\n| Cell\n|}" );
+
+		$html = $this->newExpander()->expand( new TemplateCall( '{{Infobox}}', true ) );
+
+		$this->assertStringContainsString( '<table', $html );
+	}
+
+	public function testInlineCallHasNoSurroundingParagraph(): void {
+		$this->editPage( 'Template:Box', 'Box body text' );
+
+		$html = $this->newExpander()->expand( new TemplateCall( '{{Box}}', false ) );
+
+		$this->assertStringNotContainsString( '<p>', $html );
+		$this->assertStringContainsString( 'Box body text', $html );
+	}
+
+	public function testMergeIntoRecordsTemplateDependency(): void {
+		$this->editPage( 'Template:Box', 'Box body text' );
+		$expander = $this->newExpander();
+		$expander->expand( new TemplateCall( '{{Box}}', true ) );
+
+		$output = new ParserOutput();
+		$expander->mergeInto( $output );
+
+		$this->assertArrayHasKey( 'Box', $output->getTemplates()[NS_TEMPLATE] ?? [] );
+	}
+
+	public function testMergeIntoRecordsCategoryAddedByTemplate(): void {
+		$this->editPage( 'Template:Categoriser', '[[Category:Expanded Cat]]' );
+		$expander = $this->newExpander();
+		$expander->expand( new TemplateCall( '{{Categoriser}}', true ) );
+
+		$output = new ParserOutput();
+		$expander->mergeInto( $output );
+
+		$this->assertContains( 'Expanded_Cat', $output->getCategoryNames() );
+	}
+
+	public function testMergeIntoRecordsEveryExpandedTemplate(): void {
+		$this->editPage( 'Template:First', 'first' );
+		$this->editPage( 'Template:Second', 'second' );
+		$expander = $this->newExpander();
+		$expander->expand( new TemplateCall( '{{First}}', true ) );
+		$expander->expand( new TemplateCall( '{{Second}}', true ) );
+
+		$output = new ParserOutput();
+		$expander->mergeInto( $output );
+
+		$templates = $output->getTemplates()[NS_TEMPLATE] ?? [];
+		$this->assertArrayHasKey( 'First', $templates );
+		$this->assertArrayHasKey( 'Second', $templates );
+	}
+
+}
diff --git a/tests/phpunit/TestDoubles/FakeTemplateExpander.php b/tests/phpunit/TestDoubles/FakeTemplateExpander.php
new file mode 100644
index 0000000..25e30c0
--- /dev/null
+++ b/tests/phpunit/TestDoubles/FakeTemplateExpander.php
@@ -0,0 +1,28 @@
+<?php
+
+declare( strict_types = 1 );
+
+namespace ProfessionalWiki\NativeMarkdown\Tests\TestDoubles;
+
+use ProfessionalWiki\NativeMarkdown\Application\TemplateCall;
+use ProfessionalWiki\NativeMarkdown\Application\TemplateExpander;
+
+/**
+ * Records the calls it receives and returns deterministic HTML embedding the
+ * wikitext, so tests can assert the pipeline injects the expander's raw HTML and
+ * distinguishes block from inline calls without a real MediaWiki parser.
+ */
+final class FakeTemplateExpander implements TemplateExpander {
+
+	/** @var TemplateCall[] */
+	public array $calls = [];
+
+	public function expand( TemplateCall $call ): string {
+		$this->calls[] = $call;
+
+		$tag = $call->isBlock ? 'div' : 'span';
+
+		return "<$tag class=\"fake-expanded\">" . htmlspecialchars( $call->wikitext ) . "</$tag>";
+	}
+
+}